effect 4.0.7 → 4.1.1

package/src/sql/Migrator.ts

@@ -12,11 +12,9 @@
 import * as Arr from "../Array.ts"
 import * as Data from "../Data.ts"
 import * as Effect from "../Effect.ts"
-import { FileSystem } from "../FileSystem.ts"
-import { pipe } from "../Function.ts"
+import { identity, pipe } from "../Function.ts"
 import * as Option from "../Option.ts"
 import * as Order from "../Order.ts"
-import { Path } from "../Path.ts"
 import * as Client from "./SqlClient.ts"
 import type { SqlError } from "./SqlError.ts"
 
@@ -101,13 +99,22 @@ export class MigrationError extends Data.TaggedError("MigrationError")<{
  * migrations. ClickHouse runs without a transaction and records each migration
  * only after it succeeds.
  *
+ * **Details**
+ *
+ * `transformWrites` transforms only the effects that create the migrations
+ * table and insert into it, for clients such as ClickHouse that run row-less
+ * statements differently from queries. Reads of the migrations table and the
+ * migrations themselves are not transformed. It defaults to `identity`.
+ *
  * @stability unstable
  * @category constructors
  * @since 4.0.0
  */
 export const make = <RD = never>({
+  transformWrites = identity,
   dumpSchema = () => Effect.void
 }: {
+  transformWrites?: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   dumpSchema?: (
     path: string,
     migrationsTable: string
@@ -125,7 +132,7 @@ export const make = <RD = never>({
   Effect.gen(function*() {
     const sql = yield* Client.SqlClient
 
-    const ensureMigrationsTable = sql.onDialectOrElse({
+    const createMigrationsTable = transformWrites(sql.onDialectOrElse({
       mssql: () =>
         sql`IF OBJECT_ID(N'${sql.literal(table)}', N'U') IS NULL
   CREATE TABLE ${sql(table)} (
@@ -149,14 +156,25 @@ export const make = <RD = never>({
 ) ENGINE = MergeTree
 ORDER BY migration_id`,
       pg: () =>
-        Effect.flatMap(
-          migrationsTableExists(sql, table),
-          (exists) =>
-            exists ? Effect.void : Effect.asVoid(sql`CREATE TABLE ${sql(table)} (
+        sql`CREATE TABLE ${sql(table)} (
   migration_id integer primary key,
   created_at timestamp with time zone not null default now(),
   name text not null
-)`).pipe(
+)`,
+      orElse: () =>
+        sql`CREATE TABLE IF NOT EXISTS ${sql(table)} (
+  migration_id integer PRIMARY KEY NOT NULL,
+  created_at datetime NOT NULL DEFAULT current_timestamp,
+  name VARCHAR(255) NOT NULL
+)`
+    }))
+
+    const ensureMigrationsTable = sql.onDialectOrElse({
+      pg: () =>
+        Effect.flatMap(
+          migrationsTableExists(sql, table),
+          (exists) =>
+            exists ? Effect.void : Effect.asVoid(createMigrationsTable).pipe(
               Effect.catch((error) =>
                 Effect.flatMap(
                   migrationsTableExists(sql, table),
@@ -165,22 +183,19 @@ ORDER BY migration_id`,
               )
             )
         ),
-      orElse: () =>
-        sql`CREATE TABLE IF NOT EXISTS ${sql(table)} (
-  migration_id integer PRIMARY KEY NOT NULL,
-  created_at datetime NOT NULL DEFAULT current_timestamp,
-  name VARCHAR(255) NOT NULL
-)`
+      orElse: () => createMigrationsTable
     })
 
     const insertMigrations = (
-      rows: ReadonlyArray<[id: number, name: string]>
+      rows: Arr.NonEmptyReadonlyArray<[id: number, name: string]>
     ) =>
-      sql`INSERT INTO ${sql(table)} ${
-        sql.insert(
-          rows.map(([migration_id, name]) => ({ migration_id, name }))
-        )
-      }`.withoutTransform
+      transformWrites(
+        sql`INSERT INTO ${sql(table)} ${
+          sql.insert(
+            Arr.map(rows, ([migration_id, name]) => ({ migration_id, name }))
+          )
+        }`.withoutTransform
+      )
 
     const latestMigration = Effect.map(
       sql<{ migration_id: number; name: string; created_at: Date }>`SELECT migration_id, name, created_at FROM ${
@@ -287,9 +302,9 @@ ORDER BY migration_id`,
       }
 
       // rows recorded up front are only rolled back inside a transaction
-      if (transactional && required.length > 0) {
+      if (transactional && Arr.isArrayNonEmpty(required)) {
         yield* pipe(
-          insertMigrations(required.map(([id, name]) => [id, name])),
+          insertMigrations(Arr.map(required, ([id, name]) => [id, name])),
           Effect.mapError((error): MigrationError | SqlError =>
             isConstraintConflict(error)
               ? new MigrationError({
@@ -436,60 +451,3 @@ export const fromRecord = (migrations: Record<string, Effect.Effect<void, unknow
     Arr.sort(migrationOrder),
     Effect.succeed
   )
-
-/**
- * Creates a migration loader that reads a directory with `FileSystem`, imports
- * files named `<id>_<name>.js`, `<id>_<name>.ts`,
- * `<id>_<name>.mjs`, or `<id>_<name>.mts`, and sorts migrations by id.
- *
- * **Details**
- *
- * Requires a `Path` service appropriate for the migration directory's path
- * syntax. On Windows, prefer a platform-aware implementation such as
- * `NodePath.layer`; the core `Path.layer` uses POSIX semantics and does not
- * preserve Windows drive-letter paths.
- *
- * @stability unstable
- * @category loaders
- * @since 4.0.0
- */
-export const fromFileSystem: (directory: string) => Loader<FileSystem | Path> = Effect.fnUntraced(function*(directory) {
-  const Fs = yield* FileSystem
-  const path = yield* Path
-  const files = yield* Effect.mapError(
-    Fs.readDirectory(directory),
-    (cause) =>
-      new MigrationError({
-        kind: "Failed",
-        cause,
-        message: "Failed to read migrations directory"
-      })
-  )
-  return files
-    .map((file) => Option.fromNullishOr(file.match(/^(?:.*\/)?(\d+)_([^.]+)\.(js|ts|mjs|mts)$/)))
-    .flatMap(
-      Option.match({
-        onNone: () => [],
-        onSome: ([basename, id, name]): ReadonlyArray<ResolvedMigration> =>
-          [
-            [
-              Number(id),
-              name,
-              // `import` needs a file URL: on Windows an absolute path such as
-              // `D:\migrations\1_init.ts` is rejected by the ESM loader. `orDie` keeps the
-              // failure a defect so `loadMigration` reports it as an import error.
-              Effect.flatMap(Effect.orDie(path.toFileUrl(path.join(directory, basename))), (url) =>
-                Effect.promise(
-                  () =>
-                    import(
-                      /* @vite-ignore */
-                      /* webpackIgnore: true */
-                      url.href
-                    )
-                ))
-            ]
-          ] as const
-      })
-    )
-    .sort(([a], [b]) => a - b);
-})

package/src/sql/MigratorFileSystem.ts

@@ -0,0 +1,71 @@
+/**
+ * Loads SQL migrations by reading a directory.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import * as Effect from "../Effect.ts"
+import { FileSystem } from "../FileSystem.ts"
+import * as Option from "../Option.ts"
+import { Path } from "../Path.ts"
+import { type Loader, MigrationError, type ResolvedMigration } from "./Migrator.ts"
+
+// Kept out of `Migrator.ts` and the `effect/sql` barrel: Metro rejects the
+// non-literal `import()` below in any module it bundles.
+
+/**
+ * Creates a migration loader that reads a directory with `FileSystem`, imports
+ * files named `<id>_<name>.js`, `<id>_<name>.ts`,
+ * `<id>_<name>.mjs`, or `<id>_<name>.mts`, and sorts migrations by id.
+ *
+ * **Details**
+ *
+ * Requires a `Path` service appropriate for the migration directory's path
+ * syntax. On Windows, prefer a platform-aware implementation such as
+ * `NodePath.layer`; the core `Path.layer` uses POSIX semantics and does not
+ * preserve Windows drive-letter paths.
+ *
+ * @stability unstable
+ * @category loaders
+ * @since 4.0.0
+ */
+export const fromFileSystem: (directory: string) => Loader<FileSystem | Path> = Effect.fnUntraced(function*(directory) {
+  const Fs = yield* FileSystem
+  const path = yield* Path
+  const files = yield* Effect.mapError(
+    Fs.readDirectory(directory),
+    (cause) =>
+      new MigrationError({
+        kind: "Failed",
+        cause,
+        message: "Failed to read migrations directory"
+      })
+  )
+  return files
+    .map((file) => Option.fromNullishOr(file.match(/^(?:.*\/)?(\d+)_([^.]+)\.(js|ts|mjs|mts)$/)))
+    .flatMap(
+      Option.match({
+        onNone: () => [],
+        onSome: ([basename, id, name]): ReadonlyArray<ResolvedMigration> =>
+          [
+            [
+              Number(id),
+              name,
+              // `import` needs a file URL: on Windows an absolute path such as
+              // `D:\migrations\1_init.ts` is rejected by the ESM loader. `orDie` keeps the
+              // failure a defect so `loadMigration` reports it as an import error.
+              Effect.flatMap(Effect.orDie(path.toFileUrl(path.join(directory, basename))), (url) =>
+                Effect.promise(
+                  () =>
+                    import(
+                      /* @vite-ignore */
+                      /* webpackIgnore: true */
+                      url.href
+                    )
+                ))
+            ]
+          ] as const
+      })
+    )
+    .sort(([a], [b]) => a - b);
+})

package/src/sql/SqlClient.ts

@@ -21,7 +21,6 @@ import { hasProperty } from "../Predicate.ts"
 import type * as Queue from "../Queue.ts"
 import { type KeysInput, Reactivity } from "../reactivity/Reactivity.ts"
 import type { ReadonlyRecord } from "../Record.ts"
-import { UnhandledLogLevel } from "../References.ts"
 import * as Scope from "../Scope.ts"
 import * as Semaphore from "../Semaphore.ts"
 import * as Stream from "../Stream.ts"
@@ -82,6 +81,10 @@ export interface SqlClient extends Constructor {
    * client's, such as one that sets its isolation level, provide
    * `BeginTransaction`.
    *
+   * To retry serialization failures or deadlocks, wrap the outermost
+   * `withTransaction` in `Effect.retry`. Each attempt starts a fresh
+   * transaction and re-runs the whole effect, including `COMMIT`.
+   *
    * **Gotchas**
    *
    * Deferred invalidations run individually after the commit and don't join an
@@ -89,6 +92,35 @@ export interface SqlClient extends Constructor {
    * the transaction's context defers, and a fiber that outlives the
    * transaction can't defer through it, as with `afterCommit`. Transactions
    * that don't go through `makeWithTransaction` invalidate immediately.
+   *
+   * Retrying a nested transaction only retries its savepoint, which can't
+   * recover an outer transaction the database has aborted. Since a retried
+   * effect runs more than once, keep non-transactional side effects in
+   * `afterCommit`, which discards the callbacks of a failed attempt but
+   * doesn't guarantee they run exactly once. Don't retry `ConnectionError`: a
+   * `COMMIT` that lost its connection may have committed, and retrying would
+   * apply its writes twice.
+   *
+   * **Example** (Retrying serialization failures and deadlocks)
+   *
+   * ```ts
+   * import { Effect, Schedule } from "effect"
+   * import { SqlClient } from "effect/sql"
+   *
+   * const program = Effect.gen(function*() {
+   *   const sql = yield* SqlClient.SqlClient
+   *   return yield* sql.withTransaction(
+   *     sql`UPDATE accounts SET balance = balance - 10 WHERE id = 1`
+   *   ).pipe(
+   *     Effect.provideService(SqlClient.BeginTransaction, "BEGIN ISOLATION LEVEL SERIALIZABLE"),
+   *     Effect.retry({
+   *       while: (error) => error.reason._tag === "SerializationError" || error.reason._tag === "DeadlockError",
+   *       times: 5,
+   *       schedule: Schedule.exponential("10 millis").pipe(Schedule.jittered)
+   *     })
+   *   )
+   * })
+   * ```
    */
   readonly withTransaction: <R, E, A>(
     self: Effect.Effect<A, E, R>
@@ -207,9 +239,8 @@ export declare namespace SqlClient {
     readonly spanAttributes: ReadonlyArray<readonly [string, unknown]>
     readonly transactionService?: Context.Service<TransactionConnection, TransactionConnection.Service>
     /**
-     * Whether the transaction control statements - `BEGIN`, `COMMIT`,
-     * `ROLLBACK`, and the savepoint pair - can be prepared like any other
-     * statement.
+     * Whether the transaction control statements - `BEGIN`, `COMMIT` and
+     * `SAVEPOINT` - can be prepared like any other statement.
      *
      * **Details**
      *
@@ -217,6 +248,9 @@ export declare namespace SqlClient {
      * prepare them stops parsing them again each time. Off by default,
      * because several databases refuse to prepare transaction control at all;
      * a driver has to say that its own does not.
+     *
+     * Rollbacks and savepoint releases always run unprepared, so a prepared
+     * statement the backend has dropped cannot stop cleanup.
      */
     readonly prepareTransactionControls?: boolean | undefined
     readonly beginTransaction?: string | undefined
@@ -275,20 +309,20 @@ export const make = Effect.fnUntraced(function*(options: SqlClient.MakeOptions)
   const rollback = options.rollback ?? "ROLLBACK"
   const rollbackSavepoint = options.rollbackSavepoint ?? ((name: string) => `ROLLBACK TO SAVEPOINT ${name}`)
   const transactionAcquirer = options.transactionAcquirer ?? options.acquirer
+  const unprepared = (conn: Connection.Connection, sql: string) => conn.executeUnprepared(sql, [], undefined)
   const control = options.prepareTransactionControls === true
     ? (conn: Connection.Connection, sql: string) => conn.execute(sql, [], undefined)
-    : (conn: Connection.Connection, sql: string) => conn.executeUnprepared(sql, [], undefined)
+    : unprepared
   const isTransaction = options.isTransaction
   const cleanup = isTransaction
-    ? (conn: Connection.Connection, sql: string) => isTransaction(conn) ? control(conn, sql) : Effect.void
-    : control
+    ? (conn: Connection.Connection, sql: string) => isTransaction(conn) ? unprepared(conn, sql) : Effect.void
+    : unprepared
   const withTransaction = makeWithTransaction({
     transactionService,
     spanAttributes: options.spanAttributes,
     acquireConnection: (restore) => restore(transactionAcquirer!),
     // Unlike the client's own, a provided statement isn't fixed, so it isn't prepared.
-    begin: (conn, statement) =>
-      statement === undefined ? control(conn, beginTransaction) : conn.executeUnprepared(statement, [], undefined),
+    begin: (conn, statement) => statement === undefined ? control(conn, beginTransaction) : unprepared(conn, statement),
     savepoint: (conn, id) => control(conn, savepoint(`effect_sql_${id}`)),
     releaseSavepoint: releaseSavepoint
       ? (conn, id) => cleanup(conn, releaseSavepoint(`effect_sql_${id}`))
@@ -430,13 +464,7 @@ export const makeSqliteAcquirers = <C extends Connection.Connection>(options: {
     })
   })
 
-  const lease = Effect.uninterruptibleMask((restore) =>
-    Effect.flatMap(Effect.scope, (scope) =>
-      restore(semaphore.take(1)).pipe(
-        Effect.andThen(Scope.addFinalizer(scope, semaphore.release(1))),
-        Effect.andThen(available)
-      ))
-  )
+  const lease = Effect.uninterruptibleMask((restore) => Effect.andThen(restore(semaphore.takeScoped(1)), available))
 
   return {
     acquirer: lease,
@@ -488,14 +516,7 @@ interface AfterCommitBuffer {
 const afterCommitBuffers = new WeakMap<object, AfterCommitBuffer>()
 
 const runAfterCommit = <R>(effect: Effect.Effect<void, never, R>): Effect.Effect<void, never, R> =>
-  Effect.catchCause(effect, (cause) =>
-    Effect.withFiber((fiber) => {
-      const unhandledLogLevel = fiber.getRef(UnhandledLogLevel)
-      if (unhandledLogLevel) {
-        return Effect.logWithLevel(unhandledLogLevel)("Unhandled error in SqlClient.afterCommit callback", cause)
-      }
-      return Effect.void
-    }))
+  Effect.ignoreCause(effect, { log: "Unhandled", message: "Unhandled error in SqlClient.afterCommit callback" })
 
 const makeAfterCommit =
   (transactionService: Context.Key<any, any>) =>

package/src/sql/Statement.ts

@@ -11,6 +11,7 @@
  * @stability unstable
  * @since 4.0.0
  */
+import type * as Arr from "../Array.ts"
 import { Clock } from "../Clock.ts"
 import * as Context from "../Context.ts"
 import * as Effect from "../Effect.ts"
@@ -26,7 +27,41 @@ import * as Tracer from "../Tracer.ts"
 import type { Acquirer, Borrower, Connection, Row } from "./SqlConnection.ts"
 import type { SqlError } from "./SqlError.ts"
 
-const FragmentTypeId = "~effect/sql/Statement/Fragment"
+/**
+ * Runtime type identifier for SQL `Fragment` values.
+ *
+ * @stability unstable
+ * @category Type ID
+ * @since 4.1.1
+ */
+export const FragmentTypeId: unique symbol = Symbol.for("~effect/sql/Statement/Fragment")
+
+/**
+ * Type of the unique symbol used to brand SQL `Fragment` values.
+ *
+ * @stability unstable
+ * @category Type ID
+ * @since 4.1.1
+ */
+export type FragmentTypeId = typeof FragmentTypeId
+
+/**
+ * Runtime type identifier for SQL `Segment` values.
+ *
+ * @stability unstable
+ * @category Type ID
+ * @since 4.1.1
+ */
+export const SegmentTypeId: unique symbol = Symbol.for("~effect/sql/Statement/Segment")
+
+/**
+ * Type of the unique symbol used to brand SQL `Segment` values.
+ *
+ * @stability unstable
+ * @category Type ID
+ * @since 4.1.1
+ */
+export type SegmentTypeId = typeof SegmentTypeId
 
 /**
  * Composable SQL fragment represented as low-level segments that can be
@@ -37,7 +72,7 @@ const FragmentTypeId = "~effect/sql/Statement/Fragment"
  * @since 4.0.0
  */
 export interface Fragment {
-  readonly [FragmentTypeId]: typeof FragmentTypeId
+  readonly [FragmentTypeId]: FragmentTypeId
   readonly segments: ReadonlyArray<Segment>
 }
 
@@ -146,7 +181,7 @@ export const isFragment = (u: unknown): u is Fragment => hasProperty(u, Fragment
 export const isCustom = <A extends Custom<any, any, any, any>>(
   kind: A["kind"]
 ) =>
-(u: unknown): u is A => hasProperty(u, "_tag") && u._tag === "Custom" && (u as any).kind === kind
+(u: unknown): u is A => isSegment(u) && u._tag === "Custom" && u.kind === kind
 
 /**
  * Union of low-level segment types that make up a SQL `Fragment`.
@@ -174,6 +209,7 @@ export type Segment =
  * @since 4.0.0
  */
 export interface Literal {
+  readonly [SegmentTypeId]: SegmentTypeId
   readonly _tag: "Literal"
   readonly value: string
   readonly params?: ReadonlyArray<unknown> | undefined
@@ -188,6 +224,7 @@ export interface Literal {
  * @since 4.0.0
  */
 export const literal = (value: string, params?: ReadonlyArray<unknown> | undefined): Literal => ({
+  [SegmentTypeId]: SegmentTypeId,
   _tag: "Literal",
   value,
   params
@@ -201,6 +238,7 @@ export const literal = (value: string, params?: ReadonlyArray<unknown> | undefin
  * @since 4.0.0
  */
 export interface Identifier {
+  readonly [SegmentTypeId]: SegmentTypeId
   readonly _tag: "Identifier"
   readonly value: string
 }
@@ -214,6 +252,7 @@ export interface Identifier {
  * @since 4.0.0
  */
 export const identifier = (value: string): Identifier => ({
+  [SegmentTypeId]: SegmentTypeId,
   _tag: "Identifier",
   value
 })
@@ -227,6 +266,7 @@ export const identifier = (value: string): Identifier => ({
  * @since 4.0.0
  */
 export interface Parameter {
+  readonly [SegmentTypeId]: SegmentTypeId
   readonly _tag: "Parameter"
   readonly value: unknown
 }
@@ -239,6 +279,7 @@ export interface Parameter {
  * @since 4.0.0
  */
 export const parameter = (value: unknown): Parameter => ({
+  [SegmentTypeId]: SegmentTypeId,
   _tag: "Parameter",
   value
 })
@@ -252,6 +293,7 @@ export const parameter = (value: unknown): Parameter => ({
  * @since 4.0.0
  */
 export interface ArrayHelper {
+  readonly [SegmentTypeId]: SegmentTypeId
   readonly _tag: "ArrayHelper"
   readonly value: ReadonlyArray<unknown | Fragment>
 }
@@ -264,6 +306,7 @@ export interface ArrayHelper {
  * @since 4.0.0
  */
 export const arrayHelper = (value: ReadonlyArray<unknown | Fragment>): ArrayHelper => ({
+  [SegmentTypeId]: SegmentTypeId,
   _tag: "ArrayHelper",
   value
 })
@@ -277,8 +320,9 @@ export const arrayHelper = (value: ReadonlyArray<unknown | Fragment>): ArrayHelp
  * @since 4.0.0
  */
 export interface RecordInsertHelper {
+  readonly [SegmentTypeId]: SegmentTypeId
   readonly _tag: "RecordInsertHelper"
-  readonly value: ReadonlyArray<Record<string, unknown>>
+  readonly value: Arr.NonEmptyReadonlyArray<Record<string, unknown>>
   /**
    * @internal
    */
@@ -287,6 +331,7 @@ export interface RecordInsertHelper {
 }
 
 const RecordInsertHelperProto = {
+  [SegmentTypeId]: SegmentTypeId,
   _tag: "RecordInsertHelper" as const,
   returning(this: RecordInsertHelper, sql: string | Identifier | Fragment) {
     const self = Object.create(Object.getPrototypeOf(this))
@@ -305,7 +350,7 @@ const RecordInsertHelperProto = {
  * @since 4.0.0
  */
 export const recordInsertHelper = (
-  value: ReadonlyArray<Record<string, unknown>>
+  value: Arr.NonEmptyReadonlyArray<Record<string, unknown>>
 ): RecordInsertHelper =>
   Object.assign(Object.create(RecordInsertHelperProto), {
     value,
@@ -321,8 +366,9 @@ export const recordInsertHelper = (
  * @since 4.0.0
  */
 export interface RecordUpdateHelper {
+  readonly [SegmentTypeId]: SegmentTypeId
   readonly _tag: "RecordUpdateHelper"
-  readonly value: ReadonlyArray<Record<string, unknown>>
+  readonly value: Arr.NonEmptyReadonlyArray<Record<string, unknown>>
   readonly alias: string
   /**
    * @internal
@@ -345,7 +391,7 @@ const RecordUpdateHelperProto = {
  * @since 4.0.0
  */
 export const recordUpdateHelper = (
-  value: ReadonlyArray<Record<string, unknown>>,
+  value: Arr.NonEmptyReadonlyArray<Record<string, unknown>>,
   alias: string
 ): RecordUpdateHelper =>
   Object.assign(Object.create(RecordUpdateHelperProto), {
@@ -363,6 +409,7 @@ export const recordUpdateHelper = (
  * @since 4.0.0
  */
 export interface RecordUpdateHelperSingle {
+  readonly [SegmentTypeId]: SegmentTypeId
   readonly _tag: "RecordUpdateHelperSingle"
   readonly value: Record<string, unknown>
   readonly omit: ReadonlyArray<string>
@@ -410,6 +457,7 @@ export interface Custom<
   B = void,
   C = void
 > {
+  readonly [SegmentTypeId]: SegmentTypeId
   readonly _tag: "Custom"
   readonly kind: T
   readonly paramA: A
@@ -432,7 +480,7 @@ export const custom = <C extends Custom<any, any, any, any>>(
   paramA: C["paramA"],
   paramB: C["paramB"],
   paramC: C["paramC"]
-): C => ({ _tag: "Custom", kind, paramA, paramB, paramC } as C)
+): C => ({ [SegmentTypeId]: SegmentTypeId, _tag: "Custom", kind, paramA, paramB, paramC } as C)
 
 /**
  * Names the primitive value categories recognized by SQL statement helpers and
@@ -502,7 +550,7 @@ export interface Constructor {
 
   readonly insert: {
     (
-      value: ReadonlyArray<Record<string, unknown>>
+      value: Arr.NonEmptyReadonlyArray<Record<string, unknown>>
     ): RecordInsertHelper
     (value: Record<string, unknown>): RecordInsertHelper
   }
@@ -524,7 +572,7 @@ export interface Constructor {
    * transforms.
    */
   readonly updateValues: (
-    value: ReadonlyArray<Record<string, unknown>>,
+    value: Arr.NonEmptyReadonlyArray<Record<string, unknown>>,
     alias: string
   ) => RecordUpdateHelper
 
@@ -631,7 +679,7 @@ export const make = (
       in: in_,
       insert(value: any) {
         return recordInsertHelper(
-          Array.isArray(value) ? value : [value]
+          Array.isArray(value) ? value as Arr.NonEmptyArray<Record<string, unknown>> : [value]
         )
       },
       update(value: any, omit: any) {
@@ -1612,24 +1660,7 @@ const withStatement = <A, X, E, R>(
     )
   })
 
-const isSegment = (u: unknown): u is Segment => {
-  if (!hasProperty(u, "_tag")) {
-    return false
-  }
-  switch (u._tag) {
-    case "Literal":
-    case "Parameter":
-    case "ArrayHelper":
-    case "RecordInsertHelper":
-    case "RecordUpdateHelper":
-    case "RecordUpdateHelperSingle":
-    case "Identifier":
-    case "Custom":
-      return true
-    default:
-      return false
-  }
-}
+const isSegment = (u: unknown): u is Segment => hasProperty(u, SegmentTypeId)
 
 function convertLiteralOrFragment(clause: string | Fragment): Array<Segment> {
   if (typeof clause === "string") {

package/src/sql/index.ts

@@ -3,7 +3,7 @@
  * @since 4.0.0
  */
 
-// @barrel: Auto-generated exports. Do not edit manually.
+// @barrel(!(MigratorFileSystem).ts): Auto-generated exports. Do not edit manually.
 
 /**
  * @stability unstable

package/src/testing/index.ts

@@ -17,12 +17,6 @@ export * as TestClock from "./TestClock.ts"
  */
 export * as TestConsole from "./TestConsole.ts"
 
-/**
- * @stability unstable
- * @since 4.0.0
- */
-export * as TestCrypto from "./TestCrypto.ts"
-
 /**
  * @stability unstable
  * @since 4.0.0

package/src/workflow/Workflow.ts

@@ -88,6 +88,10 @@ export interface Workflow<
    * nor gets interrupted with it. The cluster engine retains the parent for
    * observability.
    *
+   * Inside a workflow, an awaited child that is interrupted fails the parent
+   * with a defect rather than an interrupt, so the parent can recover with
+   * `Effect.catchDefect` or `Effect.exit`.
+   *
    * **Gotchas**
    *
    * Do not await a detached execution later. Executing the same payload joins

package/src/workflow/WorkflowEngine.ts

@@ -583,6 +583,11 @@ export const makeUnsafe = (options: Encoded): WorkflowEngine["Service"] =>
         if (wrapped._tag === "Suspended") {
           return yield* Workflow.suspend(parentInstance.value)
         }
+        // A child's interrupt is an outcome for the parent, not an interrupt of
+        // the parent's run, so surface it as a defect the parent can observe.
+        if (Exit.isFailure(wrapped.exit) && Cause.hasInterruptsOnly(wrapped.exit.cause)) {
+          return yield* Effect.die(`${self._tag}.execute: execution "${executionId}" was interrupted`)
+        }
         return yield* wrapped.exit
       }