effect 4.1.0 → 4.1.1

package/src/reactivity/AtomRegistry.ts

@@ -553,9 +553,15 @@ class RegistryImpl implements AtomRegistry {
     const node = this.ensureNode(atom)
     if (options?.immediate) {
       f(node.value())
-    } else if (node.state === NodeState.stale) {
-      // a listener hears the next change, which only reaches an up-to-date node
-      node.value()
+    } else {
+      // build the node so the listener hears its next change. A failed build
+      // is left for the next read to report; an error raised after the value
+      // is committed has no later read to report it, so it is rethrown
+      try {
+        node.value()
+      } catch (error) {
+        if ((node.state & NodeFlags.waitingForValue) === 0) throw error
+      }
     }
     const remove = node.subscribe(function() {
       f(node._value)
@@ -842,11 +848,15 @@ class NodeImpl<A> {
   }
 
   build(): void {
-    // a lifetime still attached to a node that needs a value belongs to a
-    // build that failed, or to one that is running and is now superseded
-    this.disposeLifetime()
-    this.invalidatedDuringBuild = false
     const lifetime = makeLifetime(this)
+    // release a failed or superseded build; its finalizers run only once, so
+    // their failure is rethrown once this build commits
+    try {
+      this.disposeLifetime()
+    } catch (error) {
+      lifetime.failure = error
+    }
+    this.invalidatedDuringBuild = false
     this.lifetime = lifetime
     let value: A
     let read = false
@@ -1126,7 +1136,8 @@ interface Lifetime<A> extends Atom.AtomContext {
   readonly node: NodeImpl<A>
   // the parents read so far by the build; `undefined` once the build has returned
   reads: Set<NodeImpl<any>> | undefined
-  // a failure met while reading a parent that still produced its value
+  // rethrown once the build commits: a failure from releasing the previous
+  // lifetime, or from reading a parent that still produced its value
   failure: unknown
   finalizers: Array<() => void> | undefined
   disposed: boolean

package/src/rpc/Rpc.ts

@@ -363,7 +363,9 @@ export type SuccessExit<R> = Success<R> extends infer T ? T extends Stream<infer
  * @category utility types
  * @since 4.0.0
  */
-export type SuccessChunk<R> = Success<R> extends Stream<infer _A, infer _E, infer _Env> ? _A : never
+export type SuccessChunk<R> = R extends Any ?
+  SuccessSchema<R> extends RpcSchema.Stream<infer _A, infer _E> ? _A["Type"] : never
+  : never
 
 /**
  * Extracts the RPC error schema, including error schemas contributed by

package/src/rpc/RpcClient.ts

@@ -113,7 +113,8 @@ export declare namespace RpcClient {
            * handler's result and error are not returned, but transport errors,
            * middleware errors and failures before the handler starts still fail the
            * call. Over HTTP and workers the call completes after the handler has
-           * finished.
+           * finished. A protocol that only delivers requests acknowledges the call
+           * itself once it has delivered the request.
            */
           readonly discard?: Discard | undefined
         }
@@ -188,7 +189,8 @@ export declare namespace RpcClient {
          * handler's result and error are not returned, but transport errors,
          * middleware errors and failures before the handler starts still fail the
          * call. Over HTTP and workers the call completes after the handler has
-         * finished.
+         * finished. A protocol that only delivers requests acknowledges the call
+         * itself once it has delivered the request.
          */
         readonly discard?: Discard | undefined
       }
@@ -418,19 +420,18 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
       let fiber: Fiber.Fiber<any, any>
       return Effect.onInterrupt(
         Effect.callback<any, any>((resume) => {
-          // the acknowledgement of a discarded call, held until its send has finished
-          let ack: Exit.Exit<any, any> | undefined
+          let acked = false
           const entry: ClientEntry = {
             _tag: "Effect",
             rpc,
             context,
             resume(exit) {
-              if (discard) {
-                // Interrupting the send could cancel the call, as an HTTP
-                // handler is scoped to its request, so the call completes
-                // once the send has finished too.
-                ack = exit._tag === "Success" ? Exit.void : exit
-                if (fiber?.pollUnsafe()) resume(ack)
+              if (discard && exit._tag === "Success") {
+                // A successful acknowledgement waits for the send to finish, as
+                // interrupting the send could cancel the call: an HTTP handler
+                // is scoped to its request. Failures complete the call at once.
+                acked = true
+                if (fiber?.pollUnsafe()) resume(Exit.void)
                 return
               }
               resume(exit)
@@ -450,8 +451,8 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
             if (exit._tag === "Failure") {
               entries.delete(id)
               return resume(exit)
-            } else if (ack) {
-              return resume(ack)
+            } else if (acked) {
+              return resume(Exit.void)
             }
           })
         }),
@@ -604,8 +605,10 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
         if (!entry || entry._tag !== "Queue") return Effect.void
         return Queue.offerAll(entry.queue, message.values).pipe(
           supportsAck
-            ? Effect.flatMap(() =>
-              options.onFromClient({
+            ? Effect.flatMap((dropped) =>
+              // values are dropped when the queue was shutdown by an interrupted
+              // consumer, so the server should not be asked for more
+              dropped.length > 0 ? Effect.void : options.onFromClient({
                 message: { _tag: "Ack", requestId: message.requestId },
                 context: entry.context
               })
@@ -831,8 +834,10 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
       }
       case "ClientProtocolError": {
         const exit = Exit.fail(message.error)
-        const requestIds = Array.from(entries.keys())
-        entries.clear()
+        const requestIds = message.requestIds === undefined
+          ? Array.from(entries.keys())
+          : message.requestIds.map(RequestId).filter((requestId) => entries.has(requestId))
+        for (const requestId of requestIds) entries.delete(requestId)
         return Effect.forEach(
           requestIds,
           (requestId) => write({ _tag: "Exit", clientId: 0, requestId, exit: exit as any })
@@ -953,6 +958,16 @@ export const withHeaders: {
  * Use to provide the transport boundary for RPC clients over HTTP, WebSocket,
  * workers, sockets, or custom protocols.
  *
+ * **Details**
+ *
+ * A `Request` that `send` accepts stays pending until a reply names its id: an
+ * `Exit`, or a `ClientProtocolError` that lists it in `requestIds`. Until then
+ * the client keeps the request and the caller's context, unless the caller is
+ * interrupted, the client closes or the connection fails. A transport that
+ * only delivers requests, such as a message queue, writes a void `Exit` for a
+ * `discard` request once the request is delivered, and fails `send` with an
+ * `RpcClientError` for any other request.
+ *
  * @stability unstable
  * @category services
  * @since 4.0.0
@@ -1599,21 +1614,26 @@ export const makeProtocolWorker = (
           undefined
       }).pipe(
         Effect.tapCause((cause) => {
+          const requestIdsByClient = new Map<number, Array<string | number>>()
           for (const [requestId, entry] of entries) {
             if (entry.worker !== backing) continue
             entries.delete(requestId)
             entry.latch.openUnsafe()
+            const requestIds = requestIdsByClient.get(entry.clientId)
+            if (requestIds) requestIds.push(requestId)
+            else requestIdsByClient.set(entry.clientId, [requestId])
           }
-          const error = Cause.findError(cause)
-          return broadcast({
-            _tag: "ClientProtocolError",
-            error: new RpcClientError({
-              reason: Result.isSuccess(error) ? error.success.reason : new RpcClientDefect({
-                message: "Error in worker",
-                cause: Cause.squash(cause)
-              })
+          const found = Cause.findError(cause)
+          const error = new RpcClientError({
+            reason: Result.isSuccess(found) ? found.success.reason : new RpcClientDefect({
+              message: "Error in worker",
+              cause: Cause.squash(cause)
             })
           })
+          return Effect.forEach(
+            requestIdsByClient,
+            ([clientId, requestIds]) => writeResponse(clientId, { _tag: "ClientProtocolError", error, requestIds })
+          )
         }),
         Effect.retry(Schedule.spaced(1000)),
         Effect.annotateLogs({

package/src/rpc/RpcMessage.ts

@@ -325,8 +325,8 @@ export interface ResponseExitEncoded {
 }
 
 /**
- * A server-to-client protocol message reporting a client protocol error to all
- * affected in-flight requests.
+ * A server-to-client protocol message failing in-flight requests with a client
+ * protocol error: those in `requestIds`, or all of them when it is omitted.
  *
  * @stability unstable
  * @category models
@@ -335,6 +335,7 @@ export interface ResponseExitEncoded {
 export interface ClientProtocolError {
   readonly _tag: "ClientProtocolError"
   readonly error: RpcClientError
+  readonly requestIds?: ReadonlyArray<string | number>
 }
 
 /**

package/src/sql/Migrator.ts

@@ -12,7 +12,7 @@
 import * as Arr from "../Array.ts"
 import * as Data from "../Data.ts"
 import * as Effect from "../Effect.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 * as Client from "./SqlClient.ts"
@@ -99,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
@@ -123,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)} (
@@ -147,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),
@@ -163,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: Arr.NonEmptyReadonlyArray<[id: number, name: string]>
     ) =>
-      sql`INSERT INTO ${sql(table)} ${
-        sql.insert(
-          Arr.map(rows, ([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 ${

package/src/sql/SqlClient.ts

@@ -81,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
@@ -88,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>
@@ -206,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**
      *
@@ -216,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
@@ -274,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}`))

package/src/sql/Statement.ts

@@ -27,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
@@ -38,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>
 }
 
@@ -147,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`.
@@ -175,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
@@ -189,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
@@ -202,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
 }
@@ -215,6 +252,7 @@ export interface Identifier {
  * @since 4.0.0
  */
 export const identifier = (value: string): Identifier => ({
+  [SegmentTypeId]: SegmentTypeId,
   _tag: "Identifier",
   value
 })
@@ -228,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
 }
@@ -240,6 +279,7 @@ export interface Parameter {
  * @since 4.0.0
  */
 export const parameter = (value: unknown): Parameter => ({
+  [SegmentTypeId]: SegmentTypeId,
   _tag: "Parameter",
   value
 })
@@ -253,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>
 }
@@ -265,6 +306,7 @@ export interface ArrayHelper {
  * @since 4.0.0
  */
 export const arrayHelper = (value: ReadonlyArray<unknown | Fragment>): ArrayHelper => ({
+  [SegmentTypeId]: SegmentTypeId,
   _tag: "ArrayHelper",
   value
 })
@@ -278,6 +320,7 @@ export const arrayHelper = (value: ReadonlyArray<unknown | Fragment>): ArrayHelp
  * @since 4.0.0
  */
 export interface RecordInsertHelper {
+  readonly [SegmentTypeId]: SegmentTypeId
   readonly _tag: "RecordInsertHelper"
   readonly value: Arr.NonEmptyReadonlyArray<Record<string, unknown>>
   /**
@@ -288,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))
@@ -322,6 +366,7 @@ export const recordInsertHelper = (
  * @since 4.0.0
  */
 export interface RecordUpdateHelper {
+  readonly [SegmentTypeId]: SegmentTypeId
   readonly _tag: "RecordUpdateHelper"
   readonly value: Arr.NonEmptyReadonlyArray<Record<string, unknown>>
   readonly alias: string
@@ -364,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>
@@ -411,6 +457,7 @@ export interface Custom<
   B = void,
   C = void
 > {
+  readonly [SegmentTypeId]: SegmentTypeId
   readonly _tag: "Custom"
   readonly kind: T
   readonly paramA: A
@@ -433,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
@@ -1613,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/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
       }