effect 4.0.0-beta.85 → 4.0.0-beta.87

package/src/unstable/persistence/Persistence.ts

@@ -67,28 +67,28 @@ export class Persistence extends Context.Service<Persistence, {
  * @since 4.0.0
  */
 export interface PersistenceStore {
-  readonly get: <A extends Schema.Top, E extends Schema.Top>(
+  readonly get: <A extends Schema.Constraint, E extends Schema.Constraint>(
     key: Persistable.Persistable<A, E>
   ) => Effect.Effect<
     Exit.Exit<A["Type"], E["Type"]> | undefined,
     PersistenceError | Schema.SchemaError,
     A["DecodingServices"] | E["DecodingServices"]
   >
-  readonly getMany: <A extends Schema.Top, E extends Schema.Top>(
+  readonly getMany: <A extends Schema.Constraint, E extends Schema.Constraint>(
     keys: Iterable<Persistable.Persistable<A, E>>
   ) => Effect.Effect<
     Array<Exit.Exit<A["Type"], E["Type"]> | undefined>,
     PersistenceError | Schema.SchemaError,
     A["DecodingServices"] | E["DecodingServices"]
   >
-  readonly set: <A extends Schema.Top, E extends Schema.Top>(
+  readonly set: <A extends Schema.Constraint, E extends Schema.Constraint>(
     key: Persistable.Persistable<A, E>,
     value: Exit.Exit<A["Type"], E["Type"]>
   ) => Effect.Effect<void, PersistenceError | Schema.SchemaError, A["EncodingServices"] | E["EncodingServices"]>
-  readonly setMany: <A extends Schema.Top, E extends Schema.Top>(
+  readonly setMany: <A extends Schema.Constraint, E extends Schema.Constraint>(
     entries: Iterable<readonly [Persistable.Persistable<A, E>, Exit.Exit<A["Type"], E["Type"]>]>
   ) => Effect.Effect<void, PersistenceError | Schema.SchemaError, A["EncodingServices"] | E["EncodingServices"]>
-  readonly remove: <A extends Schema.Top, E extends Schema.Top>(
+  readonly remove: <A extends Schema.Constraint, E extends Schema.Constraint>(
     key: Persistable.Persistable<A, E>
   ) => Effect.Effect<void, PersistenceError>
   readonly clear: Effect.Effect<void, PersistenceError>

package/src/unstable/reactivity/AsyncResult.ts

@@ -1063,8 +1063,8 @@ class BuilderImpl<Out, A, E> {
  * @since 4.0.0
  */
 export interface Schema<
-  Success extends Schema_.Top,
-  Error extends Schema_.Top
+  Success extends Schema_.Constraint,
+  Error extends Schema_.Constraint
 > extends
   Schema_.declareConstructor<
     AsyncResult<Success["Type"], Error["Type"]>,
@@ -1083,8 +1083,8 @@ export interface Schema<
  * @since 4.0.0
  */
 export const Schema = <
-  A extends Schema_.Top = Schema_.Never,
-  E extends Schema_.Top = Schema_.Never
+  A extends Schema_.Constraint = Schema_.Never,
+  E extends Schema_.Constraint = Schema_.Never
 >(
   options: {
     readonly success?: A | undefined

package/src/unstable/reactivity/Atom.ts

@@ -2947,7 +2947,7 @@ export type SerializableTypeId = "~effect-atom/atom/Atom/Serializable"
  * @category Serializable
  * @since 4.0.0
  */
-export interface Serializable<S extends Schema.Top> {
+export interface Serializable<S extends Schema.Constraint> {
   readonly [SerializableTypeId]: {
     readonly key: string
     readonly encode: (value: S["Type"]) => S["Encoded"]

package/src/unstable/reactivity/AtomHttpApi.ts

@@ -343,7 +343,7 @@ type ResponseByMode<Success, ResponseMode extends HttpApiEndpoint.ClientResponse
   : Success
 
 type ErrorByMode<
-  Error extends Schema.Top,
+  Error extends Schema.Constraint,
   Middleware,
   ResponseMode extends HttpApiEndpoint.ClientResponseMode
 > =

package/src/unstable/rpc/Rpc.ts

@@ -51,7 +51,6 @@ export const isRpc = (u: unknown): u is Rpc<any, any, any> => Predicate.hasPrope
  * @since 4.0.0
  */
 export interface DefectSchema extends Schema.Top {
-  readonly Type: unknown
   make(input: null, options?: Schema.MakeOptions): unknown
   make(input: undefined, options?: Schema.MakeOptions): unknown
   make(input: {}, options?: Schema.MakeOptions): unknown
@@ -807,7 +806,7 @@ const Proto = {
       middlewares: this.middlewares
     })
   },
-  setPayload(this: AnyWithProps, payloadSchema: Schema.Struct<any> | Schema.Struct.Fields) {
+  setPayload(this: AnyWithProps, payloadSchema: Schema.Struct<Schema.Struct.Fields> | Schema.Struct.Fields) {
     return makeProto({
       _tag: this._tag,
       payloadSchema: Schema.isSchema(payloadSchema) ? payloadSchema as any : Schema.Struct(payloadSchema as any),
@@ -876,7 +875,7 @@ const makeProto = <
   readonly payloadSchema: Payload
   readonly successSchema: Success
   readonly errorSchema: Error
-  readonly defectSchema: Schema.Top
+  readonly defectSchema: Schema.Constraint
   readonly annotations: Context.Context<never>
   readonly middlewares: ReadonlySet<Middleware>
 }): Rpc<Tag, Payload, Success, Error, Middleware, Requires> => {
@@ -971,7 +970,7 @@ export const make = <
  * }
  *
  * // The type definition for the transformed success schema.
- * export interface Paginated<S extends Schema.Top> extends
+ * export interface Paginated<S extends Schema.Constraint> extends
  *   Schema.Struct<{
  *     readonly offset: Schema.Number
  *     readonly total: Schema.Number
@@ -1071,8 +1070,8 @@ export declare namespace Custom {
    * @since 4.0.0
    */
   export interface Out<
-    Success extends Schema.Top,
-    Error extends Schema.Top
+    Success extends Schema.Constraint,
+    Error extends Schema.Constraint
   > {
     readonly success: Success
     readonly error: Error
@@ -1097,8 +1096,8 @@ export declare namespace Custom {
    */
   export type Kind<
     Def extends Custom,
-    Success extends Schema.Top,
-    Error extends Schema.Top
+    Success extends Schema.Constraint,
+    Error extends Schema.Constraint
   > = (Def & {
     readonly success: Success
     readonly error: Error

package/src/unstable/rpc/RpcClient.ts

@@ -43,7 +43,7 @@ import * as Rpc from "./Rpc.ts"
 import { RpcClientDefect, RpcClientError } from "./RpcClientError.ts"
 import type * as RpcGroup from "./RpcGroup.ts"
 import type { FromClient, FromClientEncoded, FromServer, FromServerEncoded, Request } from "./RpcMessage.ts"
-import { constPing, RequestId } from "./RpcMessage.ts"
+import { constPing, isTerminalResponse, RequestId } from "./RpcMessage.ts"
 import type * as RpcMiddleware from "./RpcMiddleware.ts"
 import * as RpcSchema from "./RpcSchema.ts"
 import * as RpcSerialization from "./RpcSerialization.ts"
@@ -901,6 +901,8 @@ export const makeProtocolHttp = (client: HttpClient.HttpClient): Effect.Effect<
       })
     const emptyResponseError = (request: FromClientEncoded) =>
       protocolDefect("Received empty HTTP response from RPC server", request)
+    const incompleteResponseError = (request: FromClientEncoded) =>
+      protocolDefect("HTTP response ended before RPC request completed", request)
 
     const send = Effect.fnUntraced(function*(clientId: number, request: FromClientEncoded) {
       if (request._tag !== "Request") {
@@ -928,15 +930,27 @@ export const makeProtocolHttp = (client: HttpClient.HttpClient): Effect.Effect<
         if (responses.length === 0) {
           return yield* emptyResponseError(request)
         }
+        let completed = false
         let i = 0
-        return yield* Effect.whileLoop({
+        yield* Effect.whileLoop({
           while: () => i < responses.length,
-          body: () => writeResponse(clientId, responses[i++]),
+          body: () => {
+            const response = responses[i++]
+            if (isTerminalResponse(response)) {
+              completed = true
+            }
+            return writeResponse(clientId, response)
+          },
           step: constVoid
         })
+        if (!completed) {
+          return yield* incompleteResponseError(request)
+        }
+        return
       }
 
       let hasResponse = false
+      let completed = false
       yield* Stream.runForEachArray(response.stream, (chunk) =>
         Effect.try({
           try: () => chunk.flatMap(parser.decode) as Array<FromServerEncoded>,
@@ -948,7 +962,13 @@ export const makeProtocolHttp = (client: HttpClient.HttpClient): Effect.Effect<
             let i = 0
             return Effect.whileLoop({
               while: () => i < responses.length,
-              body: () => writeResponse(clientId, responses[i++]),
+              body: () => {
+                const response = responses[i++]
+                if (isTerminalResponse(response)) {
+                  completed = true
+                }
+                return writeResponse(clientId, response)
+              },
               step: constVoid
             })
           })
@@ -957,6 +977,8 @@ export const makeProtocolHttp = (client: HttpClient.HttpClient): Effect.Effect<
         )
       if (!hasResponse) {
         return yield* emptyResponseError(request)
+      } else if (!completed) {
+        return yield* incompleteResponseError(request)
       }
     })
 

package/src/unstable/rpc/RpcMessage.ts

@@ -400,3 +400,22 @@ export interface Pong {
  * @since 4.0.0
  */
 export const constPong: Pong = { _tag: "Pong" }
+
+/**
+ * Checks if the response type is terminal.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+export const isTerminalResponse = (response: FromServerEncoded): boolean => {
+  switch (response._tag) {
+    case "Exit":
+    case "Defect":
+    case "ClientProtocolError": {
+      return true
+    }
+    default: {
+      return false
+    }
+  }
+}

package/src/unstable/rpc/RpcMiddleware.ts

@@ -142,7 +142,7 @@ export interface ServiceClass<
   Self,
   Name extends string,
   Provides,
-  E extends Schema.Top,
+  E extends Schema.Constraint,
   ClientError,
   Requires,
   RequiredForClient extends boolean
@@ -193,7 +193,7 @@ export type ApplyServices<A, R> = Exclude<R, Provides<A>> | Requires<A>
  * @since 4.0.0
  */
 export type ErrorSchema<A> = A extends { readonly [TypeId]: { readonly error: infer E } }
-  ? E extends Schema.Top ? E : never
+  ? E extends Schema.Constraint ? E : never
   : never
 
 /**

package/src/unstable/rpc/RpcSchema.ts

@@ -26,12 +26,12 @@ const StreamSchemaTypeId = "~effect/rpc/RpcSchema/StreamSchema"
  * @category streams
  * @since 4.0.0
  */
-export function isStreamSchema(schema: Schema.Top): schema is Stream<Schema.Top, Schema.Top> {
+export function isStreamSchema(schema: Schema.Constraint): schema is Stream<Schema.Top, Schema.Top> {
   return Predicate.hasProperty(schema, StreamSchemaTypeId)
 }
 
 /** @internal */
-export function getStreamSchemas(schema: Schema.Top): Option.Option<{
+export function getStreamSchemas(schema: Schema.Constraint): Option.Option<{
   readonly success: Schema.Top
   readonly error: Schema.Top
 }> {
@@ -50,17 +50,20 @@ export function getStreamSchemas(schema: Schema.Top): Option.Option<{
  * @category streams
  * @since 4.0.0
  */
-export interface Stream<A extends Schema.Top, E extends Schema.Top> extends
-  Schema.Bottom<
-    Stream_.Stream<A["Type"], E["Type"]>,
-    Stream_.Stream<A["Encoded"], E["Encoded"]>,
-    A["DecodingServices"] | E["DecodingServices"],
-    A["EncodingServices"] | E["EncodingServices"],
+export interface Stream<A extends Schema.Constraint, E extends Schema.Constraint> extends
+  Schema.BottomLazy<
     SchemaAST.Declaration,
     Stream<A, E>
   >
 {
+  readonly "Type": Stream_.Stream<A["Type"], E["Type"]>
+  readonly "Encoded": Stream_.Stream<A["Encoded"], E["Encoded"]>
+  readonly "DecodingServices": A["DecodingServices"] | E["DecodingServices"]
+  readonly "EncodingServices": A["EncodingServices"] | E["EncodingServices"]
   readonly "Rebuild": Stream<A, E>
+  readonly "~type.make.in": Stream_.Stream<A["Type"], E["Type"]>
+  readonly "~type.make": Stream_.Stream<A["Type"], E["Type"]>
+  readonly "Iso": Stream_.Stream<A["Type"], E["Type"]>
   readonly [StreamSchemaTypeId]: typeof StreamSchemaTypeId
   readonly success: A
   readonly error: E
@@ -75,7 +78,7 @@ const schema = Schema.declare(Stream_.isStream)
  * @category streams
  * @since 4.0.0
  */
-export function Stream<A extends Schema.Top, E extends Schema.Top>(success: A, error: E): Stream<A, E> {
+export function Stream<A extends Schema.Constraint, E extends Schema.Constraint>(success: A, error: E): Stream<A, E> {
   return Schema.make(schema.ast, { [StreamSchemaTypeId]: StreamSchemaTypeId, success, error })
 }
 

package/src/unstable/rpc/RpcWorker.ts

@@ -64,7 +64,7 @@ const ProtocolTag = Context.Service<Protocol, Protocol["Service"]>(
  * @category initial message
  * @since 4.0.0
  */
-export const makeInitialMessage = <S extends Schema.Top, E, R2>(
+export const makeInitialMessage = <S extends Schema.Constraint, E, R2>(
   schema: S,
   effect: Effect.Effect<S["Type"], E, R2>
 ): Effect.Effect<
@@ -89,7 +89,7 @@ export const makeInitialMessage = <S extends Schema.Top, E, R2>(
  * @category initial message
  * @since 4.0.0
  */
-export const layerInitialMessage = <S extends Schema.Top, R2>(
+export const layerInitialMessage = <S extends Schema.Constraint, R2>(
   schema: S,
   build: Effect.Effect<S["Type"], never, R2>
 ): Layer.Layer<InitialMessage, never, S["EncodingServices"] | R2> =>
@@ -108,7 +108,7 @@ export const layerInitialMessage = <S extends Schema.Top, R2>(
  * @category initial message
  * @since 4.0.0
  */
-export const initialMessage = <S extends Schema.Top>(
+export const initialMessage = <S extends Schema.Constraint>(
   schema: S
 ): Effect.Effect<S["Type"], NoSuchElementError | Schema.SchemaError, Protocol | S["DecodingServices"]> =>
   ProtocolTag.pipe(

package/src/unstable/schema/Model.ts

@@ -298,7 +298,7 @@ export const Sensitive = <S extends Schema.Top>(schema: S): Sensitive<S> =>
  * @category optional
  * @since 4.0.0
  */
-export interface optionalOption<S extends Schema.Top>
+export interface optionalOption<S extends Schema.Constraint>
   extends Schema.decodeTo<Schema.Option<Schema.toType<S>>, Schema.optionalKey<Schema.NullOr<S>>>
 {}
 
@@ -309,7 +309,7 @@ export interface optionalOption<S extends Schema.Top>
  * @category optional
  * @since 4.0.0
  */
-export const optionalOption = <S extends Schema.Top>(schema: S): optionalOption<S> =>
+export const optionalOption = <S extends Schema.Constraint>(schema: S): optionalOption<S> =>
   Schema.optionalKey(Schema.NullOr(schema)).pipe(
     Schema.decodeTo(
       Schema.Option(Schema.toType(schema)),

package/src/unstable/schema/VariantSchema.ts

@@ -262,17 +262,10 @@ export interface Class<
     readonly fields: Schema.Struct.Fields
   }
 > extends
-  Schema.Bottom<
-    Self,
-    S["Encoded"],
-    S["DecodingServices"],
-    S["EncodingServices"],
+  Schema.BottomLazy<
     SchemaAST.Declaration,
     Schema.decodeTo<Schema.declareConstructor<Self, S["Encoded"], readonly [S], S["Iso"]>, S>,
-    S["~type.make.in"],
-    S["Iso"],
     readonly [S],
-    Self,
     S["~type.mutability"],
     S["~type.optionality"],
     S["~type.constructor.default"],
@@ -281,6 +274,14 @@ export interface Class<
   >,
   Struct<Struct_.Simplify<Fields>>
 {
+  readonly "Type": Self
+  readonly "Encoded": S["Encoded"]
+  readonly "DecodingServices": S["DecodingServices"]
+  readonly "EncodingServices": S["EncodingServices"]
+  readonly "~type.make.in": S["~type.make.in"]
+  readonly "~type.make": Self
+  readonly "Iso": S["Iso"]
+
   new(
     props: S["~type.make.in"],
     options?: {
@@ -528,24 +529,25 @@ export const Override = <A>(value: A): A & Brand<"Override"> => value as any
  * @since 4.0.0
  */
 export interface Overrideable<S extends Schema.Top & Schema.WithoutConstructorDefault> extends
-  Schema.Bottom<
-    S["Type"] & Brand<"Override">,
-    S["Encoded"],
-    S["DecodingServices"],
-    S["EncodingServices"],
+  Schema.BottomLazy<
     S["ast"],
     Overrideable<S>,
-    S["~type.make.in"],
-    (S["Type"] & Brand<"Override">) | undefined,
     S["~type.parameters"],
-    (S["Type"] & Brand<"Override">) | undefined,
     S["~type.mutability"],
     "required",
     "with-default",
     S["~encoded.mutability"],
     S["~encoded.optionality"]
   >
-{}
+{
+  readonly "Type": S["Type"] & Brand<"Override">
+  readonly "Encoded": S["Encoded"]
+  readonly "DecodingServices": S["DecodingServices"]
+  readonly "EncodingServices": S["EncodingServices"]
+  readonly "~type.make.in": S["~type.make.in"]
+  readonly "~type.make": (S["Type"] & Brand<"Override">) | undefined
+  readonly "Iso": (S["Type"] & Brand<"Override">) | undefined
+}
 
 /**
  * Wraps a schema with an effectful constructor default while allowing explicit

package/src/unstable/sql/SqlConnection.ts

@@ -50,6 +50,11 @@ export interface Connection {
     params: ReadonlyArray<unknown>
   ) => Effect<ReadonlyArray<ReadonlyArray<unknown>>, SqlError>
 
+  readonly executeValuesUnprepared: (
+    sql: string,
+    params: ReadonlyArray<unknown>
+  ) => Effect<ReadonlyArray<ReadonlyArray<unknown>>, SqlError>
+
   readonly executeUnprepared: (
     sql: string,
     params: ReadonlyArray<unknown>,

package/src/unstable/sql/SqlModel.ts

@@ -77,7 +77,7 @@ export const makeRepository = <
 > =>
   Effect.gen(function*() {
     const sql = yield* SqlClient
-    const idSchema = Model.fields[options.idColumn] as Schema.Top
+    const idSchema = Model.fields[options.idColumn]
     const idColumn = options.idColumn as string
     const softDeleteColumn = options.softDeleteColumn as string | undefined
     const withSoftDeleteFilter = (where: any) =>
@@ -274,7 +274,7 @@ export const makeResolvers = <
 > =>
   Effect.gen(function*() {
     const sql = yield* SqlClient
-    const idSchema = Model.fields[options.idColumn] as Schema.Top
+    const idSchema = Model.fields[options.idColumn]
     const idColumn = options.idColumn as string
     const softDeleteColumn = options.softDeleteColumn as string | undefined
     const withSoftDeleteFilter = (where: any) =>

package/src/unstable/sql/SqlResolver.ts

@@ -110,7 +110,7 @@ export const SqlRequest = <In, A, E, R>(payload: In): SqlRequest<In, A, E, R> =>
  * @category resolvers
  * @since 4.0.0
  */
-export const ordered = <Req extends Schema.Top, Res extends Schema.Top, _, E, R>(
+export const ordered = <Req extends Schema.Constraint, Res extends Schema.Constraint, _, E, R>(
   options: {
     readonly Request: Req
     readonly Result: Res
@@ -158,7 +158,7 @@ export const ordered = <Req extends Schema.Top, Res extends Schema.Top, _, E, R>
  * @category resolvers
  * @since 4.0.0
  */
-export const grouped = <Req extends Schema.Top, Res extends Schema.Top, K, Row, E, R>(
+export const grouped = <Req extends Schema.Constraint, Res extends Schema.Constraint, K, Row, E, R>(
   options: {
     readonly Request: Req
     readonly RequestGroupKey: (request: Req["Type"]) => K
@@ -227,7 +227,7 @@ export const grouped = <Req extends Schema.Top, Res extends Schema.Top, K, Row,
  * @category resolvers
  * @since 4.0.0
  */
-export const findById = <Id extends Schema.Top, Res extends Schema.Top, Row, E, R>(
+export const findById = <Id extends Schema.Constraint, Res extends Schema.Constraint, Row, E, R>(
   options: {
     readonly Id: Id
     readonly Result: Res
@@ -284,7 +284,7 @@ export const findById = <Id extends Schema.Top, Res extends Schema.Top, Row, E,
   })
 }
 
-const void_ = <Req extends Schema.Top, _, E, R>(
+const void_ = <Req extends Schema.Constraint, _, E, R>(
   options: {
     readonly Request: Req
     readonly execute: (
@@ -334,7 +334,7 @@ const constNoSuchElement = Exit.fail(new Cause.NoSuchElementError())
 
 const partitionRequests = function*<In, A, E, R, InE>(
   requests: Arr.NonEmptyArray<Request.Entry<SqlRequest<In, A, E, R>>>,
-  schema: Schema.Codec<In, InE, R, R>
+  schema: Schema.ConstraintCodec<In, InE, R, R>
 ) {
   const len = requests.length
   const inputs = Arr.empty<InE>()
@@ -359,7 +359,7 @@ const partitionRequests = function*<In, A, E, R, InE>(
 
 const partitionRequestsById = function*<In, A, E, R, InE>(
   requests: ReadonlyArray<Request.Entry<SqlRequest<In, A, E, R>>>,
-  schema: Schema.Codec<In, InE, R, R>
+  schema: Schema.ConstraintCodec<In, InE, R, R>
 ) {
   const len = requests.length
   const inputs = Arr.empty<InE>()

package/src/unstable/sql/SqlSchema.ts

@@ -30,7 +30,7 @@ import * as Schema from "../../Schema.ts"
  * @category constructors
  * @since 4.0.0
  */
-export const findAll = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
+export const findAll = <Req extends Schema.Constraint, Res extends Schema.Constraint, E, R>(
   options: {
     readonly Request: Req
     readonly Result: Res
@@ -62,7 +62,7 @@ export const findAll = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
  * @category constructors
  * @since 4.0.0
  */
-export const findNonEmpty = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
+export const findNonEmpty = <Req extends Schema.Constraint, Res extends Schema.Constraint, E, R>(
   options: {
     readonly Request: Req
     readonly Result: Res
@@ -83,7 +83,7 @@ export const findNonEmpty = <Req extends Schema.Top, Res extends Schema.Top, E,
         : Effect.fail(new Cause.NoSuchElementError()))
 }
 
-const void_ = <Req extends Schema.Top, E, R>(
+const void_ = <Req extends Schema.Constraint, E, R>(
   options: {
     readonly Request: Req
     readonly execute: (request: Req["Encoded"]) => Effect.Effect<unknown, E, R>
@@ -112,7 +112,7 @@ export {
  * @category constructors
  * @since 4.0.0
  */
-export const findOne = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
+export const findOne = <Req extends Schema.Constraint, Res extends Schema.Constraint, E, R>(
   options: {
     readonly Request: Req
     readonly Result: Res
@@ -145,7 +145,7 @@ export const findOne = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
  * @category constructors
  * @since 4.0.0
  */
-export const findOneOption = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
+export const findOneOption = <Req extends Schema.Constraint, Res extends Schema.Constraint, E, R>(
   options: {
     readonly Request: Req
     readonly Result: Res

package/src/unstable/sql/Statement.ts

@@ -72,6 +72,7 @@ export interface Statement<A> extends Fragment, Effect.Effect<ReadonlyArray<A>,
   readonly withoutTransform: Effect.Effect<ReadonlyArray<A>, SqlError>
   readonly stream: Stream.Stream<A, SqlError>
   readonly values: Effect.Effect<ReadonlyArray<ReadonlyArray<unknown>>, SqlError>
+  readonly valuesUnprepared: Effect.Effect<ReadonlyArray<ReadonlyArray<unknown>>, SqlError>
   readonly unprepared: Effect.Effect<ReadonlyArray<A>, SqlError>
   readonly compile: (withoutTransform?: boolean | undefined) => readonly [
     sql: string,
@@ -1368,6 +1369,16 @@ const StatementProto: Omit<
     return this.withConnection("executeValues", (connection, sql, params) => connection.executeValues(sql, params))
   },
 
+  get valuesUnprepared(): Effect.Effect<
+    ReadonlyArray<ReadonlyArray<unknown>>,
+    SqlError
+  > {
+    return this.withConnection(
+      "executeValuesUnprepared",
+      (connection, sql, params) => connection.executeValuesUnprepared(sql, params)
+    )
+  },
+
   get unprepared(): Effect.Effect<ReadonlyArray<any>, SqlError> {
     const self = this as StatementImpl<any>
     return self.withConnection(

package/src/unstable/workflow/Activity.ts

@@ -34,8 +34,8 @@ const TypeId = "~effect/workflow/Activity"
  * @since 4.0.0
  */
 export interface Activity<
-  Success extends Schema.Top = Schema.Void,
-  Error extends Schema.Top = Schema.Never,
+  Success extends Schema.Constraint = Schema.Void,
+  Error extends Schema.Constraint = Schema.Never,
   R = never
 > extends
   Effect.Effect<
@@ -122,8 +122,8 @@ export interface AnyWithProps {
  */
 export const make = <
   R,
-  Success extends Schema.Top = Schema.Void,
-  Error extends Schema.Top = Schema.Never
+  Success extends Schema.Constraint = Schema.Void,
+  Error extends Schema.Constraint = Schema.Never
 >(options: {
   readonly name: string
   readonly success?: Success | undefined
@@ -312,8 +312,8 @@ const InstanceTag = Context.Service<WorkflowInstance, WorkflowInstance["Service"
 
 const makeExecute = Effect.fnUntraced(function*<
   R,
-  Success extends Schema.Top = typeof Schema.Void,
-  Error extends Schema.Top = typeof Schema.Never
+  Success extends Schema.Constraint = typeof Schema.Void,
+  Error extends Schema.Constraint = typeof Schema.Never
 >(activity: Activity<Success, Error, R>) {
   const engine = yield* EngineTag
   const instance = yield* InstanceTag