effect 4.0.0-beta.64 → 4.0.0-beta.66

package/src/unstable/http/HttpBody.ts

@@ -376,7 +376,7 @@ export const file = (
   }
 ): Effect.Effect<Stream, PlatformError.PlatformError, FileSystem.FileSystem> =>
   Effect.flatMap(
-    FileSystem.FileSystem.asEffect(),
+    FileSystem.FileSystem,
     (fs) =>
       Effect.map(fs.stat(path), (info) =>
         stream(
@@ -401,7 +401,7 @@ export const fileFromInfo = (
   }
 ): Effect.Effect<Stream, PlatformError.PlatformError, FileSystem.FileSystem> =>
   Effect.map(
-    FileSystem.FileSystem.asEffect(),
+    FileSystem.FileSystem,
     (fs) =>
       stream(
         fs.stream(path, options),

package/src/unstable/http/HttpClient.ts

@@ -119,7 +119,7 @@ export const HttpClient: Context.Service<HttpClient, HttpClient> = Context.Servi
 
 const accessor = (method: keyof HttpClient) => (...args: Array<any>): Effect.Effect<any, any, any> =>
   Effect.flatMap(
-    HttpClient.asEffect(),
+    HttpClient,
     (client) => (client as any)[method](...args)
   )
 

package/src/unstable/http/HttpClientRequest.ts

@@ -1051,8 +1051,8 @@ export const toWeb = (self: HttpClientRequest, options?: {
   readonly signal?: AbortSignal | undefined
 }): Effect.Effect<Request, UrlParams.UrlParamsError> =>
   Effect.contextWith((context) =>
-    toWebResult(self, {
+    Effect.fromResult(toWebResult(self, {
       context: context,
       signal: options?.signal
-    }).asEffect()
+    }))
   )

package/src/unstable/http/HttpMiddleware.ts

@@ -105,9 +105,8 @@ export const SpanNameGenerator = Context.Reference<(request: HttpServerRequest)
  */
 export const logger: <E, R>(
   httpApp: Effect.Effect<HttpServerResponse, E, HttpServerRequest | R>
-) => Effect.Effect<HttpServerResponse, E, HttpServerRequest | R> = make((httpApp) => {
-  let counter = 0
-  return Effect.withFiber((fiber) => {
+) => Effect.Effect<HttpServerResponse, E, HttpServerRequest | R> = make((httpApp) =>
+  Effect.withFiber((fiber) => {
     const request = Context.getUnsafe(fiber.context, HttpServerRequest)
     const path = stripSearchAndHash(request.url)
     return Effect.withLogSpan(
@@ -134,10 +133,10 @@ export const logger: <E, R>(
           exit
         )
       }),
-      `http.span.${++counter}`
+      "http.span"
     )
   })
-})
+)
 
 /**
  * @since 4.0.0

package/src/unstable/http/HttpPlatform.ts

@@ -121,7 +121,7 @@ export const make: (impl: {
  * @category layers
  */
 export const layer = Layer.effect(HttpPlatform)(
-  Effect.flatMap(FileSystem.FileSystem.asEffect(), (fs) =>
+  Effect.flatMap(FileSystem.FileSystem, (fs) =>
     make({
       fileResponse(path, status, statusText, headers, start, end, contentLength) {
         return Response.stream(

package/src/unstable/http/HttpRouter.ts

@@ -148,7 +148,7 @@ export const make = Effect.gen(function*() {
                 Effect.succeed(handler) :
                 Effect.isEffect(handler)
                 ? handler
-                : Effect.flatMap(HttpServerRequest.HttpServerRequest.asEffect(), handler),
+                : Effect.flatMap(HttpServerRequest.HttpServerRequest, handler),
               uninterruptible: options?.uninterruptible ?? false,
               prefix
             })
@@ -240,7 +240,7 @@ export const params: Effect.Effect<
   ReadonlyRecord<string, string | undefined>,
   never,
   RouteContext
-> = Effect.map(RouteContext.asEffect(), (_) => _.params)
+> = Effect.map(RouteContext, (_) => _.params)
 
 /**
  * @since 4.0.0
@@ -385,8 +385,7 @@ export const schemaPathParams = <A, I extends Readonly<Record<string, string | u
  */
 export const use = <A, E, R>(
   f: (router: HttpRouter) => Effect.Effect<A, E, R>
-): Layer.Layer<never, E, HttpRouter | Exclude<R, Scope.Scope>> =>
-  Layer.effectDiscard(Effect.flatMap(HttpRouter.asEffect(), f))
+): Layer.Layer<never, E, HttpRouter | Exclude<R, Scope.Scope>> => Layer.effectDiscard(Effect.flatMap(HttpRouter, f))
 
 /**
  * Create a layer that adds a single route to the HTTP router.
@@ -559,7 +558,7 @@ export const route = <E = never, R = never>(
       Effect.succeed(handler) :
       Effect.isEffect(handler)
       ? handler
-      : Effect.flatMap(HttpServerRequest.HttpServerRequest.asEffect(), handler),
+      : Effect.flatMap(HttpServerRequest.HttpServerRequest, handler),
     uninterruptible: options?.uninterruptible ?? false
   })
 

package/src/unstable/http/HttpServer.ts

@@ -201,7 +201,7 @@ export const addressFormattedWith = <A, E, R>(
   f: (address: string) => Effect.Effect<A, E, R>
 ): Effect.Effect<A, E, HttpServer | R> =>
   Effect.flatMap(
-    HttpServer.asEffect(),
+    HttpServer,
     (server) => f(formatAddress(server.address))
   )
 

package/src/unstable/http/HttpServerRequest.ts

@@ -121,7 +121,7 @@ export const upgradeChannel = <IE = never>(): Channel.Channel<
   unknown,
   HttpServerRequest
 > =>
-  HttpServerRequest.asEffect().pipe(
+  HttpServerRequest.pipe(
     Effect.flatMap((_) => _.upgrade),
     Effect.map(Socket.toChannelWith<IE>()),
     Channel.unwrap
@@ -136,7 +136,7 @@ export const schemaCookies = <A, I extends Readonly<Record<string, string | unde
   options?: ParseOptions | undefined
 ): Effect.Effect<A, Schema.SchemaError, RD | HttpServerRequest> => {
   const parse = Schema.decodeUnknownEffect(schema)
-  return Effect.flatMap(HttpServerRequest.asEffect(), (req) => parse(req.cookies, options))
+  return Effect.flatMap(HttpServerRequest, (req) => parse(req.cookies, options))
 }
 
 /**
@@ -148,7 +148,7 @@ export const schemaHeaders = <A, I extends Readonly<Record<string, string | unde
   options?: ParseOptions | undefined
 ): Effect.Effect<A, Schema.SchemaError, HttpServerRequest | RD> => {
   const parse = Schema.decodeUnknownEffect(schema)
-  return Effect.flatMap(HttpServerRequest.asEffect(), (req) => parse(req.headers, options))
+  return Effect.flatMap(HttpServerRequest, (req) => parse(req.headers, options))
 }
 
 /**
@@ -165,7 +165,7 @@ export const schemaSearchParams = <
   options?: ParseOptions | undefined
 ): Effect.Effect<A, Schema.SchemaError, ParsedSearchParams | RD> => {
   const parse = Schema.decodeUnknownEffect(schema)
-  return Effect.flatMap(ParsedSearchParams.asEffect(), (params) => parse(params, options))
+  return Effect.flatMap(ParsedSearchParams, (params) => parse(params, options))
 }
 /**
  * @since 4.0.0
@@ -176,7 +176,7 @@ export const schemaBodyJson = <A, I, RD, RE>(
   options?: ParseOptions | undefined
 ): Effect.Effect<A, HttpServerError | Schema.SchemaError, HttpServerRequest | RD> => {
   const parse = HttpIncomingMessage.schemaBodyJson(schema, options)
-  return Effect.flatMap(HttpServerRequest.asEffect(), parse)
+  return Effect.flatMap(HttpServerRequest, parse)
 }
 
 const isMultipart = (request: HttpServerRequest) =>
@@ -193,7 +193,7 @@ export const schemaBodyForm = <A, I extends Partial<Multipart.Persisted>, RD, RE
 ) => {
   const parseMultipart = Multipart.schemaPersisted(schema)
   const parseUrlParams = HttpIncomingMessage.schemaBodyUrlParams(schema as Schema.Codec<A, any, RD, RE>, options)
-  return Effect.flatMap(HttpServerRequest.asEffect(), (request): Effect.Effect<
+  return Effect.flatMap(HttpServerRequest, (request): Effect.Effect<
     A,
     Multipart.MultipartError | Schema.SchemaError | HttpServerError,
     RD | HttpServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path
@@ -219,7 +219,7 @@ export const schemaBodyUrlParams = <
   options?: ParseOptions | undefined
 ): Effect.Effect<A, HttpServerError | Schema.SchemaError, HttpServerRequest | RD> => {
   const parse = HttpIncomingMessage.schemaBodyUrlParams(schema, options)
-  return Effect.flatMap(HttpServerRequest.asEffect(), parse)
+  return Effect.flatMap(HttpServerRequest, parse)
 }
 
 /**
@@ -235,7 +235,7 @@ export const schemaBodyMultipart = <A, I extends Partial<Multipart.Persisted>, R
   HttpServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path | RD
 > => {
   const parse = Multipart.schemaPersisted(schema)
-  return HttpServerRequest.asEffect().pipe(
+  return HttpServerRequest.pipe(
     Effect.flatMap((_) => _.multipart),
     Effect.flatMap((_) => parse(_, options))
   )
@@ -256,7 +256,7 @@ export const schemaBodyFormJson = <A, I, RD, RE>(
       Schema.decodeEffect
     )
     return Effect.flatMap(
-      HttpServerRequest.asEffect(),
+      HttpServerRequest,
       (request): Effect.Effect<
         A,
         Schema.SchemaError | HttpServerError,
@@ -933,8 +933,8 @@ export const toWeb = (self: HttpServerRequest, options?: {
   readonly signal?: AbortSignal | undefined
 }): Effect.Effect<Request, RequestError> =>
   Effect.contextWith((context) =>
-    toWebResult(self, {
+    Effect.fromResult(toWebResult(self, {
       context,
       signal: options?.signal
-    }).asEffect()
+    }))
   )

package/src/unstable/http/HttpServerResponse.ts

@@ -379,7 +379,7 @@ export const file = (
     })
     | undefined
 ): Effect.Effect<HttpServerResponse, PlatformError, HttpPlatform> =>
-  Effect.flatMap(HttpPlatformKey.asEffect(), (platform) => platform.fileResponse(path, options))
+  Effect.flatMap(HttpPlatformKey, (platform) => platform.fileResponse(path, options))
 
 /**
  * @since 4.0.0
@@ -395,7 +395,7 @@ export const fileWeb = (
     })
     | undefined
 ): Effect.Effect<HttpServerResponse, never, HttpPlatform> =>
-  Effect.flatMap(HttpPlatformKey.asEffect(), (platform) => platform.fileWebResponse(file, options))
+  Effect.flatMap(HttpPlatformKey, (platform) => platform.fileWebResponse(file, options))
 
 /**
  * @since 4.0.0
@@ -520,7 +520,7 @@ export const setCookie: {
     options?: Cookies.Cookie["options"]
   ): Effect.Effect<HttpServerResponse, Cookies.CookiesError> =>
     Effect.map(
-      Cookies.set(self.cookies, name, value, options).asEffect(),
+      Effect.fromResult(Cookies.set(self.cookies, name, value, options)),
       (cookies) =>
         makeResponse({
           ...self,
@@ -561,7 +561,7 @@ export const expireCookie: {
     options?: Omit<NonNullable<Cookies.Cookie["options"]>, "expires" | "maxAge">
   ): Effect.Effect<HttpServerResponse, Cookies.CookiesError> =>
     Effect.map(
-      Cookies.expireCookie(self.cookies, name, options).asEffect(),
+      Effect.fromResult(Cookies.expireCookie(self.cookies, name, options)),
       (cookies) =>
         makeResponse({
           ...self,
@@ -733,7 +733,7 @@ export const setCookies: {
       ]
     >
   ): Effect.Effect<HttpServerResponse, Cookies.CookiesError> =>
-    Effect.map(Cookies.setAll(self.cookies, cookies).asEffect(), (cookies) =>
+    Effect.map(Effect.fromResult(Cookies.setAll(self.cookies, cookies)), (cookies) =>
       makeResponse({
         ...self,
         cookies

package/src/unstable/http/Multipart.ts

@@ -455,7 +455,7 @@ class FileImpl extends PartBase implements File {
 
 const defaultWriteFile = (path: string, file: File) =>
   Effect.flatMap(
-    FileSystem.FileSystem.asEffect(),
+    FileSystem.FileSystem,
     (fs) =>
       Effect.mapError(
         Stream.run(file.content, fs.sink(path)),

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -364,7 +364,7 @@ export const securityDecode = <Security extends HttpApiSecurity.HttpApiSecurity>
   switch (self._tag) {
     case "Bearer": {
       return Effect.map(
-        HttpServerRequest.asEffect(),
+        HttpServerRequest,
         (request) => Redacted.make((request.headers.authorization ?? "").slice(bearerLen)) as any
       )
     }
@@ -392,9 +392,9 @@ export const securityDecode = <Security extends HttpApiSecurity.HttpApiSecurity>
         username: "",
         password: Redacted.make("")
       } as any
-      return HttpServerRequest.asEffect().pipe(
+      return HttpServerRequest.pipe(
         Effect.flatMap((request) =>
-          Encoding.decodeBase64String((request.headers.authorization ?? "").slice(basicLen)).asEffect()
+          Effect.fromResult(Encoding.decodeBase64String((request.headers.authorization ?? "").slice(basicLen)))
         ),
         Effect.match({
           onFailure: () => empty,
@@ -722,7 +722,7 @@ const makeSecurityMiddleware = (
       }
       return result.success
     }
-    return yield* lastResult!.asEffect()
+    return yield* Effect.fromResult(lastResult!)
   })
 
   securityMiddlewareCache.set(service, middleware)

package/src/unstable/httpapi/HttpApiClient.ts

@@ -386,7 +386,7 @@ export const make = <ApiId extends string, Groups extends HttpApiGroup.Any>(
   never,
   HttpClient.HttpClient | HttpApiGroup.MiddlewareClient<Groups>
 > =>
-  Effect.flatMap(HttpClient.HttpClient.asEffect(), (httpClient) =>
+  Effect.flatMap(HttpClient.HttpClient, (httpClient) =>
     makeWith(api, {
       ...options,
       httpClient: options?.transformClient ? options.transformClient(httpClient) : httpClient

package/src/unstable/httpapi/HttpApiMiddleware.ts

@@ -1,6 +1,8 @@
 /**
  * @since 4.0.0
  */
+/** @effect-diagnostics floatingEffect:skip-file */
+/** @effect-diagnostics classSelfMismatch:off */
 import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
@@ -280,7 +282,6 @@ export const Service = <
   const creationError = new Err()
   Err.stackTraceLimit = limit
 
-  /** @effect-diagnostics-next-line classSelfMismatch:off */
   class Service extends Context.Service<Self, any>()(id) {}
   const self = Service as any
   Object.defineProperty(Service, "stack", {

package/src/unstable/httpapi/HttpApiTest.ts

@@ -31,7 +31,10 @@ export const groups = Effect.fnUntraced(function*<
   SelectedGroups = HttpApiGroup.WithName<Groups, Names[number]>
 >(
   api: HttpApi.HttpApi<ApiId, Groups>,
-  groupNames: Names
+  groupNames: Names,
+  options?: {
+    readonly baseUrl?: string | URL | undefined
+  }
 ): Effect.fn.Return<
   HttpApiClient.Client<Groups>,
   never,
@@ -90,6 +93,6 @@ export const groups = Effect.fnUntraced(function*<
 
   return yield* HttpApiClient.makeWith(api, {
     httpClient,
-    baseUrl: "http://localhost:3000"
+    baseUrl: options?.baseUrl ?? "http://localhost:3000"
   })
 })

package/src/unstable/persistence/RateLimiter.ts

@@ -666,5 +666,5 @@ export const layerStoreRedisConfig = (
 ): Layer.Layer<RateLimiterStore, Config.ConfigError, Redis.Redis> =>
   Layer.effect(
     RateLimiterStore,
-    Effect.flatMap(Config.unwrap(options).asEffect(), makeStoreRedis)
+    Effect.flatMap(Config.unwrap(options), makeStoreRedis)
   )

package/src/unstable/process/ChildProcess.ts

@@ -40,11 +40,11 @@
  *
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import type * as Duration from "../../Duration.ts"
 import type * as Effect from "../../Effect.ts"
+import * as Effectable from "../../Effectable.ts"
 import { dual } from "../../Function.ts"
-import { PipeInspectableProto, YieldableProto } from "../../internal/core.ts"
-import type { Pipeable } from "../../Pipeable.ts"
 import type * as PlatformError from "../../PlatformError.ts"
 import * as Predicate from "../../Predicate.ts"
 import type * as Scope from "../../Scope.ts"
@@ -74,9 +74,7 @@ export type Command =
  * @category Models
  */
 export interface StandardCommand extends
-  Pipeable,
-  Effect.Yieldable<
-    StandardCommand,
+  Effect.Effect<
     ChildProcessHandle,
     PlatformError.PlatformError,
     ChildProcessSpawner | Scope.Scope
@@ -96,9 +94,7 @@ export interface StandardCommand extends
  * @category Models
  */
 export interface PipedCommand extends
-  Pipeable,
-  Effect.Yieldable<
-    PipedCommand,
+  Effect.Effect<
     ChildProcessHandle,
     PlatformError.PlatformError,
     ChildProcessSpawner | Scope.Scope
@@ -510,12 +506,13 @@ export type TemplateExpression = TemplateExpressionItem | ReadonlyArray<Template
 // =============================================================================
 
 const Proto = {
-  ...PipeInspectableProto,
-  ...YieldableProto,
-  [TypeId]: TypeId,
-  asEffect(this: Command) {
-    return ChildProcessSpawner.use((_) => _.spawn(this))
-  }
+  ...Effectable.Prototype<Command>({
+    label: "Command",
+    evaluate(fiber) {
+      return Context.getUnsafe(fiber.context, ChildProcessSpawner).spawn(this)
+    }
+  }),
+  [TypeId]: TypeId
 }
 
 /**

package/src/unstable/reactivity/Atom.ts

@@ -2316,7 +2316,7 @@ export const modify: {
 } = dual(
   2,
   <R, W, A>(self: Writable<R, W>, f: (_: R) => [returnValue: A, nextValue: W]): Effect.Effect<A, never, AtomRegistry> =>
-    Effect.map(AtomRegistry.asEffect(), (_) => _.modify(self, f))
+    Effect.map(AtomRegistry, (_) => _.modify(self, f))
 )
 
 /**
@@ -2337,7 +2337,7 @@ export const set: {
 } = dual(
   2,
   <R, W>(self: Writable<R, W>, value: W): Effect.Effect<void, never, AtomRegistry> =>
-    Effect.map(AtomRegistry.asEffect(), (_) => _.set(self, value))
+    Effect.map(AtomRegistry, (_) => _.set(self, value))
 )
 
 /**
@@ -2358,7 +2358,7 @@ export const update: {
 } = dual(
   2,
   <R, W>(self: Writable<R, W>, f: (_: R) => W): Effect.Effect<void, never, AtomRegistry> =>
-    Effect.map(AtomRegistry.asEffect(), (_) => _.update(self, f))
+    Effect.map(AtomRegistry, (_) => _.update(self, f))
 )
 
 /**
@@ -2375,7 +2375,7 @@ export const getResult = <A, E>(
  * @category Conversions
  */
 export const refresh = <A>(self: Atom<A>): Effect.Effect<void, never, AtomRegistry> =>
-  Effect.map(AtomRegistry.asEffect(), (_) => _.refresh(self))
+  Effect.map(AtomRegistry, (_) => _.refresh(self))
 
 /**
  * @since 4.0.0

package/src/unstable/rpc/RpcClient.ts

@@ -916,7 +916,7 @@ export const layerProtocolHttp = (options: {
 }): Layer.Layer<Protocol, never, RpcSerialization.RpcSerialization | HttpClient.HttpClient> =>
   Layer.effect(Protocol)(
     Effect.flatMap(
-      HttpClient.HttpClient.asEffect(),
+      HttpClient.HttpClient,
       (client) => {
         client = HttpClient.mapRequest(client, HttpClientRequest.prependUrl(options.url))
         return makeProtocolHttp(options.transformClient ? options.transformClient(client) : client)

package/src/unstable/rpc/RpcServer.ts

@@ -961,6 +961,7 @@ export const makeProtocolWithHttpEffect: Effect.Effect<
     const id = clientId++
     const queue = yield* Queue.make<Uint8Array | FromServerEncoded, Cause.Done>()
     const parser = serialization.makeUnsafe()
+    const requestIds: Array<RequestId> = []
 
     const offer = (data: Uint8Array | string) =>
       typeof data === "string" ? Queue.offer(queue, encoder.encode(data)) : Queue.offer(queue, data)
@@ -993,8 +994,6 @@ export const makeProtocolWithHttpEffect: Effect.Effect<
     clients.set(id, client)
     clientIds.add(id)
 
-    const requestIds: Array<RequestId> = []
-
     // @effect-diagnostics-next-line tryCatchInEffectGen:off
     try {
       const decoded = parser.decode(data) as ReadonlyArray<FromClientEncoded>

package/src/unstable/rpc/RpcWorker.ts

@@ -85,8 +85,8 @@ export const layerInitialMessage = <S extends Schema.Top, R2>(
 export const initialMessage = <S extends Schema.Top>(
   schema: S
 ): Effect.Effect<S["Type"], NoSuchElementError | Schema.SchemaError, Protocol | S["DecodingServices"]> =>
-  ProtocolTag.asEffect().pipe(
+  ProtocolTag.pipe(
     Effect.flatMap((protocol) => protocol.initialMessage),
-    Effect.flatMap((o) => o.asEffect()),
+    Effect.flatMap(Effect.fromOption),
     Effect.flatMap(Schema.decodeUnknownEffect(Schema.toCodecJson(schema)))
   )

package/src/unstable/socket/Socket.ts

@@ -448,7 +448,7 @@ export const makeChannel = <IE = never>(): Channel.Channel<
   IE,
   unknown,
   Socket
-> => Channel.unwrap(Effect.map(Socket.asEffect(), toChannelWith<IE>()))
+> => Channel.unwrap(Effect.map(Socket, toChannelWith<IE>()))
 
 /**
  * @since 4.0.0

package/src/unstable/sql/Migrator.ts

@@ -114,7 +114,7 @@ export const make = <RD = never>({
   migration_id integer primary key,
   created_at timestamp with time zone not null default now(),
   name text not null
-)`.asEffect()
+)`
         ),
       orElse: () =>
         sql`CREATE TABLE IF NOT EXISTS ${sql(table)} (
@@ -237,7 +237,7 @@ export const make = <RD = never>({
         yield* pipe(
           insertMigrations(required.map(([id, name]) => [id, name])),
           Effect.mapError((error): MigrationError | SqlError =>
-            error.reason._tag === "ConstraintError"
+            isConstraintConflict(error)
               ? new MigrationError({
                 kind: "Locked",
                 message: "Migrations already running"
@@ -297,6 +297,9 @@ export const make = <RD = never>({
 
 const migrationOrder = Order.make<ResolvedMigration>(([a], [b]) => Order.Number(a, b))
 
+const isConstraintConflict = (error: SqlError): boolean =>
+  error.reason._tag === "ConstraintError" || error.reason._tag === "UniqueViolation"
+
 /**
  * @since 4.0.0
  * @category loaders

package/src/unstable/sql/SqlError.ts

@@ -91,6 +91,31 @@ export class SqlSyntaxError extends Schema.TaggedErrorClass<SqlSyntaxError>("eff
   }
 }
 
+const UniqueViolationFields = {
+  ...ReasonFields,
+  constraint: Schema.String
+}
+
+/**
+ * @since 4.0.0
+ */
+export class UniqueViolation extends Schema.TaggedErrorClass<UniqueViolation>("effect/sql/SqlError/UniqueViolation")(
+  "UniqueViolation",
+  UniqueViolationFields
+) {
+  /**
+   * @since 4.0.0
+   */
+  readonly [ReasonTypeId] = ReasonTypeId
+
+  /**
+   * @since 4.0.0
+   */
+  get isRetryable(): boolean {
+    return false
+  }
+}
+
 /**
  * @since 4.0.0
  */
@@ -217,6 +242,7 @@ export type SqlErrorReason =
   | AuthenticationError
   | AuthorizationError
   | SqlSyntaxError
+  | UniqueViolation
   | ConstraintError
   | DeadlockError
   | SerializationError
@@ -232,6 +258,7 @@ export const SqlErrorReason: Schema.Union<[
   typeof AuthenticationError,
   typeof AuthorizationError,
   typeof SqlSyntaxError,
+  typeof UniqueViolation,
   typeof ConstraintError,
   typeof DeadlockError,
   typeof SerializationError,
@@ -243,6 +270,7 @@ export const SqlErrorReason: Schema.Union<[
   AuthenticationError,
   AuthorizationError,
   SqlSyntaxError,
+  UniqueViolation,
   ConstraintError,
   DeadlockError,
   SerializationError,
@@ -317,9 +345,48 @@ const sqliteNumericCodeFromCause = (cause: unknown): number | undefined => {
   return typeof errno === "number" ? errno : undefined
 }
 
+const matchesSqliteNumericCode = (cause: unknown, expected: number): boolean => {
+  const code = sqliteCodeFromCause(cause)
+  if (code === expected) {
+    return true
+  }
+  if (!Predicate.hasProperty(cause, "errno")) {
+    return false
+  }
+  return cause.errno === expected
+}
+
 const matchesSqliteCode = (code: string, expected: string): boolean =>
   code === expected || code.startsWith(expected + "_")
 
+const UNKNOWN_CONSTRAINT = "unknown"
+const SQLITE_CONSTRAINT_UNIQUE = "SQLITE_CONSTRAINT_UNIQUE"
+const SQLITE_CONSTRAINT_UNIQUE_CODE = 2067
+
+const normalizeConstraintIdentifier = (identifier: unknown): string => {
+  if (typeof identifier !== "string") {
+    return UNKNOWN_CONSTRAINT
+  }
+  const trimmed = identifier.trim()
+  return trimmed.length === 0 ? UNKNOWN_CONSTRAINT : trimmed
+}
+
+const sqliteUniqueConstraintFromCause = (cause: unknown): string => {
+  if (Predicate.hasProperty(cause, "constraint")) {
+    return normalizeConstraintIdentifier(cause.constraint)
+  }
+  if (!Predicate.hasProperty(cause, "message")) {
+    return UNKNOWN_CONSTRAINT
+  }
+  const message = cause.message
+  if (typeof message !== "string") {
+    return UNKNOWN_CONSTRAINT
+  }
+  const prefix = "UNIQUE constraint failed:"
+  const index = message.indexOf(prefix)
+  return index === -1 ? UNKNOWN_CONSTRAINT : normalizeConstraintIdentifier(message.slice(index + prefix.length))
+}
+
 /**
  * @since 4.0.0
  */
@@ -333,6 +400,11 @@ export const classifySqliteError = (
     operation
   }
   const code = sqliteCodeFromCause(cause)
+  const numericCode = sqliteNumericCodeFromCause(cause)
+
+  if (code === SQLITE_CONSTRAINT_UNIQUE || matchesSqliteNumericCode(cause, SQLITE_CONSTRAINT_UNIQUE_CODE)) {
+    return new UniqueViolation({ ...props, constraint: sqliteUniqueConstraintFromCause(cause) })
+  }
 
   if (typeof code === "string") {
     if (matchesSqliteCode(code, "SQLITE_AUTH")) {
@@ -352,7 +424,6 @@ export const classifySqliteError = (
     }
   }
 
-  const numericCode = sqliteNumericCodeFromCause(cause)
   if (typeof numericCode === "number") {
     const code = numericCode & 0xff
     switch (code) {

package/src/unstable/workflow/Activity.ts

@@ -256,7 +256,7 @@ export const raceAll = <const Activities extends NonEmptyReadonlyArray<Any>>(
     error: Schema.Union(
       activities.map((activity) => (activity as any).errorSchema)
     ),
-    effects: activities.map((activity) => (activity as any).asEffect()) as any
+    effects: activities.map((activity) => (activity as any)) as any
   }) as any
 
 // -----------------------------------------------------------------------------