@effect-app/vue 4.0.0-beta.4 → 4.0.0-beta.40

package/src/form.ts

@@ -22,6 +22,7 @@ function getObjectsAST(ast: S.AST.AST): S.AST.Objects | null {
   return null
 }
 
+/** @deprecated Use OmegaForm instead */
 export function convertIn(v: string | null, type?: "text" | "float" | "int") {
   return v === null ? "" : type === "text" ? v : `${v}`
 }
@@ -30,8 +31,10 @@ export function convertIn(v: string | null, type?: "text" | "float" | "int") {
  * Makes sure our international number format is converted to js int/float format.
  * Right now assumes . for thousands and , for decimal.
  */
+/** @deprecated Use OmegaForm instead */
 export const prepareNumberForLocale = (v: string) => v.replace(/\./g, "").replace(/,/g, ".")
 
+/** @deprecated Use OmegaForm instead */
 export function convertOutInt(v: string, type?: "text" | "float" | "int") {
   v = v == null ? v : v.trim()
   const c = v === ""
@@ -49,6 +52,7 @@ export function convertOutInt(v: string, type?: "text" | "float" | "int") {
   return c
 }
 
+/** @deprecated Use OmegaForm instead */
 export function convertOut(v: string, set: (v: {} | null) => void, type?: "text" | "float" | "int") {
   return set(convertOutInt(v, type))
 }
@@ -143,10 +147,18 @@ function handlePropertySignature(
             const typeLiteral = getObjectsAST(ps.type)
 
             const tagPropertySignature = typeLiteral?.propertySignatures.find((_) => _.name === "_tag")
-            const tagLiteral = tagPropertySignature
-                && S.AST.isLiteral(tagPropertySignature.type)
-                && typeof tagPropertySignature.type.literal === "string"
-              ? tagPropertySignature.type.literal
+            // unwrap single-element Union to Literal (S.Struct({ _tag: S.Literal("x") }) wraps as Union([Literal("x")]))
+            const tagType = tagPropertySignature
+              ? S.AST.isUnion(tagPropertySignature.type)
+                  && tagPropertySignature.type.types.length === 1
+                  && S.AST.isLiteral(tagPropertySignature.type.types[0]!)
+                ? tagPropertySignature.type.types[0]!
+                : tagPropertySignature.type
+              : undefined
+            const tagLiteral = tagType
+                && S.AST.isLiteral(tagType)
+                && typeof tagType.literal === "string"
+              ? tagType.literal
               : void 0
 
             const toRet = handlePropertySignature(ps)
@@ -189,6 +201,7 @@ function handlePropertySignature(
   }
 }
 
+/** @deprecated Use OmegaForm instead */
 export function buildFieldInfoFromFields<
   From extends Record<PropertyKey, any>,
   To extends Record<PropertyKey, any>
@@ -198,6 +211,7 @@ export function buildFieldInfoFromFields<
   return buildFieldInfoFromFieldsRoot(schema).fields
 }
 
+/** @deprecated Use OmegaForm instead */
 export function buildFieldInfoFromFieldsRoot<
   From extends Record<PropertyKey, any>,
   To extends Record<PropertyKey, any>,
@@ -235,7 +249,9 @@ abstract class PhantomTypeParameter<
 
 const defaultIntl = createIntl({ locale: "en" })
 
+/** @deprecated Use OmegaForm instead */
 export const translate = ref<IntlFormatters["formatMessage"]>(defaultIntl.formatMessage)
+/** @deprecated Use OmegaForm instead */
 export const customSchemaErrors = ref<Map<S.AST.AST | string, (message: string, e: unknown, v: unknown) => string>>(
   new Map()
 )
@@ -269,7 +285,7 @@ function buildFieldInfo(
     }
 
     // parse specific error types for better translation support
-    const integerMatch = err.match(/Expected.*integer.*actual\s+(.+)/i)
+    const integerMatch = err.match(/Expected.*integer.*(?:actual|got)\s+([^)]+)/i)
     if (integerMatch) {
       return translate.value(
         { defaultMessage: "Expected an integer, actual {actualValue}", id: "validation.integer.expected" },
@@ -277,7 +293,7 @@ function buildFieldInfo(
       )
     }
 
-    const numberMatch = err.match(/Expected.*number.*actual\s+(.+)/i)
+    const numberMatch = err.match(/Expected.*number.*(?:actual|got)\s+([^)]+)/i)
     if (numberMatch) {
       return translate.value(
         { defaultMessage: "Expected a number, actual {actualValue}", id: "validation.number.expected" },
@@ -398,6 +414,7 @@ function buildFieldInfo(
   return info as any
 }
 
+/** @deprecated Use OmegaForm instead */
 export function getMetadataFromSchema(
   ast: S.AST.AST
 ): {

package/src/makeClient.ts

@@ -1,5 +1,4 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
 import { type InvalidateOptions, type InvalidateQueryFilters, isCancelledError, type QueryObserverResult, type RefetchOptions, type UseQueryReturnType } from "@tanstack/vue-query"
 import { camelCase } from "change-case"
 import { Cause, Data, Effect, Exit, Layer, type ManagedRuntime, Match, Option, S, ServiceMap, Struct } from "effect-app"
@@ -10,6 +9,7 @@ import { constant, identity, pipe, tuple } from "effect-app/Function"
 import { type OperationFailure, OperationSuccess } from "effect-app/Operations"
 import { dropUndefinedT, extendM } from "effect-app/utils"
 import { type Fiber } from "effect/Fiber"
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
 import { computed, type ComputedRef, onBeforeUnmount, type Ref, ref, watch, type WatchSource } from "vue"
 import { reportMessage } from "./errorReporter.js"
 import { type Commander, CommanderStatic } from "./experimental/commander.js"
@@ -20,6 +20,7 @@ import { buildFieldInfoFromFieldsRoot } from "./form.js"
 import { reportRuntimeError } from "./lib.js"
 import { asResult, makeMutation, type MutationOptions, type MutationOptionsBase, mutationResultToVue, type Res, useMakeMutation } from "./mutate.js"
 import { type CustomUndefinedInitialQueryOptions, makeQuery } from "./query.js"
+import { makeRunPromise } from "./runtime.js"
 
 const mapHandler = <A, E, R, I = void, A2 = A, E2 = E, R2 = R>(
   handler: Effect.Effect<A, E, R> | ((i: I) => Effect.Effect<A, E, R>),
@@ -1023,7 +1024,7 @@ export class LegacyMutationImpl<RT> {
     const isDirty = ref(false)
     const isValid = ref(true)
     const isLoading = ref(false)
-    const runPromise = Effect.runPromiseWith(this.getRuntime())
+    const runPromise = makeRunPromise(this.getRuntime())
 
     const submit1 =
       (onSubmit: (a: To) => Effect.Effect<OnSubmitA, never, never>) =>
@@ -1163,7 +1164,7 @@ export class QueryImpl<R> {
   } = <Arg, E, A, Request extends Req, Name extends string>(
     self: RequestHandlerWithInput<Arg, A, E, R, Request, Name> | RequestHandler<A, E, R, Request, Name>
   ) => {
-    const runPromise = Effect.runPromiseWith(this.getRuntime())
+    const runPromise = makeRunPromise(this.getRuntime())
     const q = this.useQuery(self as any) as any
     return (argOrOptions?: any, options?: any) => {
       const [resultRef, latestRef, fetch, uqrt] = q(argOrOptions, { ...options, suspense: true } // experimental_prefetchInRender: true }

package/src/mutate.ts

@@ -1,10 +1,10 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
 import { type InvalidateOptions, type InvalidateQueryFilters, type QueryClient, useQueryClient } from "@tanstack/vue-query"
 import { type Cause, Effect, type Exit, Option } from "effect-app"
 import { type Req } from "effect-app/client"
 import type { ClientForOptions, RequestHandler, RequestHandlerWithInput } from "effect-app/client/clientFor"
 import { tuple } from "effect-app/Function"
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
 import { computed, type ComputedRef, shallowRef } from "vue"
 import { makeQueryKey } from "./lib.js"
 

package/src/query.ts

@@ -2,16 +2,17 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
 import { type DefaultError, type Enabled, type InitialDataFunction, type NonUndefinedGuard, type PlaceholderDataFunction, type QueryKey, type QueryObserverOptions, type QueryObserverResult, type RefetchOptions, useQuery as useTanstackQuery, useQueryClient, type UseQueryDefinedReturnType, type UseQueryReturnType } from "@tanstack/vue-query"
-import { Array, Cause, Effect, Exit, flow, Option, S, type ServiceMap } from "effect-app"
+import { Array, Cause, Effect, Option, S, type ServiceMap } from "effect-app"
 import { type Req } from "effect-app/client"
 import type { RequestHandler, RequestHandlerWithInput } from "effect-app/client/clientFor"
 import { ServiceUnavailableError } from "effect-app/client/errors"
 import { type Span } from "effect/Tracer"
 import { isHttpClientError } from "effect/unstable/http/HttpClientError"
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
 import { computed, type ComputedRef, type MaybeRefOrGetter, ref, shallowRef, watch, type WatchSource } from "vue"
 import { makeQueryKey, reportRuntimeError } from "./lib.js"
+import { makeRunPromise } from "./runtime.js"
 
 // we must use interface extends, or we get the dreaded typescript error of isn't portable blabla @tanstack/vue-query/build/modern/types.js
 // but because how they are dealing with some extends clause, we loose all properties except initialData
@@ -131,13 +132,7 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
     // TODO
   ) => {
     // we wrap into KnownFiberFailure because we want to keep the full cause of the failure.
-    const runPromise = flow(Effect.runPromiseExitWith(getRuntime()), (_) =>
-      _.then(
-        Exit.match({
-          onFailure: (cause) => Promise.reject(new KnownFiberFailure(cause)),
-          onSuccess: (value) => Promise.resolve(value)
-        })
-      ))
+    const runPromise = makeRunPromise(getRuntime())
     const arr = arg
     const req: { value: I } = !arg
       ? undefined
@@ -151,9 +146,20 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
     const queryKey = makeQueryKey(q)
     const handler = q.handler
 
+    const defaultOptions = {
+      // we do not want to throw errors, because we turn the success and error responses into a Result type
+      // why don't we turn the error/success response into a Result type before returning to tanstack query? because we want to leverage tanstack query's retry and caching mechanism, which relies on throwing errors to trigger retries, and we don't want to interfere with that by catching the errors too early.
+      // but if we allow tanstack query to throw, it will trigger the error boundary in Vue - via a "watcher callback" error - which we currently report and log, which is not what we want.
+      // TODO: we might want to rethink the strategy of how to handle errors that happen after the initial load.
+      // For suspense, the initial load is captured by the suspense boundary.
+      // For subsequent loads (or non suspense use) we currently are required to use the QueryResult component to conditionally render error/loading/etc.
+      throwOnError: false
+    }
+
     const r = useTanstackQuery<A, KnownFiberFailure<E>, TData>(
       Effect.isEffect(handler)
         ? {
+          ...defaultOptions,
           ...options,
           retry: (retryCount, error) => {
             if (error instanceof KnownFiberFailure) {
@@ -177,6 +183,7 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
             )
         }
         : {
+          ...defaultOptions,
           ...options,
           retry: (retryCount, error) => {
             if (error instanceof KnownFiberFailure) {

package/src/runtime.ts

@@ -1,5 +1,7 @@
-import { ManagedRuntime } from "effect"
+import { Exit, flow, ManagedRuntime } from "effect"
 import { Effect, Layer, Logger } from "effect-app"
+import { type ServiceMap } from "effect-app/ServiceMap"
+import { KnownFiberFailure } from "./query.js"
 
 export function makeAppRuntime<A, E>(layer: Layer.Layer<A, E>) {
   return Effect.gen(function*() {
@@ -29,3 +31,13 @@ export function initializeAsync<A, E>(layer: Layer.Layer<A, E, never>) {
   return Effect
     .runPromise(makeAppRuntime(layer))
 }
+
+// we wrap into KnownFiberFailure because we want to keep the full cause of the failure.
+export const makeRunPromise = <T>(services: ServiceMap<T>) =>
+  flow(Effect.runPromiseExitWith(services), (_) =>
+    _.then(
+      Exit.match({
+        onFailure: (cause) => Promise.reject(new KnownFiberFailure(cause)),
+        onSuccess: (value) => Promise.resolve(value)
+      })
+    ))

package/test/dist/stubs.d.ts

@@ -23,16 +23,12 @@ declare const RequestContextMap_base: (new () => {
 };
 export declare class RequestContextMap extends RequestContextMap_base {
 }
-export declare const Req: <_Self>() => {
+export declare const Req: <Self>() => {
     <Tag extends string, Payload extends S.Struct.Fields, C extends {
         success: S.Top | S.Struct.Fields;
         error: S.Top | S.Struct.Fields;
-    }>(tag: Tag, fields: Payload, config: RpcContextMap.GetContextConfig<{}> & C): S.TaggedStruct<Tag, Payload> & {
-        new (...args: any[]): any;
+    }>(tag: Tag, fields: Payload, config: RpcContextMap.GetContextConfig<{}> & C): S.EnhancedClass<Self, S.TaggedStruct<Tag, Payload>, {}> & {
         readonly _tag: Tag;
-        readonly fields: {
-            readonly _tag: S.tag<Tag>;
-        } & Payload;
         readonly success: C["success"] extends infer T ? T extends C["success"] ? T extends S.Top ? T : T extends S.Struct.Fields ? S.Struct<T> : S.Void : never : never;
         readonly error: C extends {
             error: infer E;
@@ -41,16 +37,15 @@ export declare const Req: <_Self>() => {
         readonly "~decodingServices": S.Codec.DecodingServices<C["success"] extends infer T_1 ? T_1 extends C["success"] ? T_1 extends S.Top ? T_1 : T_1 extends S.Struct.Fields ? S.Struct<T_1> : S.Void : never : never> | S.Codec.DecodingServices<C extends {
             error: infer E;
         } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : never>;
+        readonly "~encodingServices": S.Codec.EncodingServices<C["success"] extends infer T_2 ? T_2 extends C["success"] ? T_2 extends S.Top ? T_2 : T_2 extends S.Struct.Fields ? S.Struct<T_2> : S.Void : never : never> | S.Codec.EncodingServices<C extends {
+            error: infer E;
+        } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : never>;
     };
     <Tag extends string, Payload_1 extends S.Struct.Fields, C_1 extends Pick<{
         success: S.Top | S.Struct.Fields;
         error: S.Top | S.Struct.Fields;
-    }, "success">>(tag: Tag, fields: Payload_1, config: RpcContextMap.GetContextConfig<{}> & C_1): S.TaggedStruct<Tag, Payload_1> & {
-        new (...args: any[]): any;
+    }, "success">>(tag: Tag, fields: Payload_1, config: RpcContextMap.GetContextConfig<{}> & C_1): S.EnhancedClass<Self, S.TaggedStruct<Tag, Payload_1>, {}> & {
         readonly _tag: Tag;
-        readonly fields: {
-            readonly _tag: S.tag<Tag>;
-        } & Payload_1;
         readonly success: C_1["success"] extends infer T ? T extends C_1["success"] ? T extends S.Top ? T : T extends S.Struct.Fields ? S.Struct<T> : S.Void : never : never;
         readonly error: C_1 extends {
             error: infer E;
@@ -59,17 +54,16 @@ export declare const Req: <_Self>() => {
         readonly "~decodingServices": S.Codec.DecodingServices<C_1["success"] extends infer T_1 ? T_1 extends C_1["success"] ? T_1 extends S.Top ? T_1 : T_1 extends S.Struct.Fields ? S.Struct<T_1> : S.Void : never : never> | S.Codec.DecodingServices<C_1 extends {
             error: infer E;
         } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : never>;
+        readonly "~encodingServices": S.Codec.EncodingServices<C_1["success"] extends infer T_2 ? T_2 extends C_1["success"] ? T_2 extends S.Top ? T_2 : T_2 extends S.Struct.Fields ? S.Struct<T_2> : S.Void : never : never> | S.Codec.EncodingServices<C_1 extends {
+            error: infer E;
+        } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : never>;
     };
     <Tag extends string, Payload_2 extends S.Struct.Fields, C_2 extends Pick<{
         success: S.Top | S.Struct.Fields;
         error: S.Top | S.Struct.Fields;
-    }, "error">>(tag: Tag, fields: Payload_2, config: RpcContextMap.GetContextConfig<{}> & C_2): S.TaggedStruct<Tag, Payload_2> & {
-        new (...args: any[]): any;
+    }, "error">>(tag: Tag, fields: Payload_2, config: RpcContextMap.GetContextConfig<{}> & C_2): S.EnhancedClass<Self, S.TaggedStruct<Tag, Payload_2>, {}> & {
         readonly _tag: Tag;
-        readonly fields: {
-            readonly _tag: S.tag<Tag>;
-        } & Payload_2;
-        readonly success: S.Codec<void, void, never, never>;
+        readonly success: S.decodeTo<S.Any, S.declare<unknown, unknown>, never, never>;
         readonly error: C_2 extends {
             error: infer E;
         } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : never;
@@ -77,14 +71,13 @@ export declare const Req: <_Self>() => {
         readonly "~decodingServices": S.Codec.DecodingServices<C_2 extends {
             error: infer E;
         } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : never>;
+        readonly "~encodingServices": S.Codec.EncodingServices<C_2 extends {
+            error: infer E;
+        } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : never>;
     };
-    <Tag extends string, Payload_3 extends S.Struct.Fields, C_3 extends Record<string, any>>(tag: Tag, fields: Payload_3, config: C_3 & RpcContextMap.GetContextConfig<{}>): S.TaggedStruct<Tag, Payload_3> & {
-        new (...args: any[]): any;
+    <Tag extends string, Payload_3 extends S.Struct.Fields, C_3 extends Record<string, any>>(tag: Tag, fields: Payload_3, config: C_3 & RpcContextMap.GetContextConfig<{}>): S.EnhancedClass<Self, S.TaggedStruct<Tag, Payload_3>, {}> & {
         readonly _tag: Tag;
-        readonly fields: {
-            readonly _tag: S.tag<Tag>;
-        } & Payload_3;
-        readonly success: S.Codec<void, void, never, never>;
+        readonly success: S.decodeTo<S.Any, S.declare<unknown, unknown>, never, never>;
         readonly error: C_3 extends {
             error: infer E;
         } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : never;
@@ -92,48 +85,37 @@ export declare const Req: <_Self>() => {
         readonly "~decodingServices": S.Codec.DecodingServices<C_3 extends {
             error: infer E;
         } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : never>;
+        readonly "~encodingServices": S.Codec.EncodingServices<C_3 extends {
+            error: infer E;
+        } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : never>;
     };
-    <Tag extends string, Payload_4 extends S.Struct.Fields>(tag: Tag, fields: Payload_4): S.TaggedStruct<Tag, Payload_4> & {
-        new (...args: any[]): any;
+    <Tag extends string, Payload_4 extends S.Struct.Fields>(tag: Tag, fields: Payload_4): S.EnhancedClass<Self, S.TaggedStruct<Tag, Payload_4>, {}> & {
         readonly _tag: Tag;
-        readonly fields: {
-            readonly _tag: S.tag<Tag>;
-        } & Payload_4;
-        readonly success: S.Codec<void, void, never, never>;
+        readonly success: S.decodeTo<S.Any, S.declare<unknown, unknown>, never, never>;
         readonly error: never;
         readonly config: Record<string, never>;
         readonly "~decodingServices": never;
+        readonly "~encodingServices": never;
     };
 };
-declare const GetSomething2_base: S.TaggedStruct<"GetSomething2", {
+declare const GetSomething2_base: S.EnhancedClass<GetSomething2, S.TaggedStruct<"GetSomething2", {
     id: S.String;
-}> & {
-    new (...args: any[]): any;
+}>, {}> & {
     readonly _tag: "GetSomething2";
-    readonly fields: {
-        readonly _tag: S.tag<"GetSomething2">;
-    } & {
-        id: S.String;
-    };
-    readonly success: S.NumberFromString;
+    readonly success: S.FiniteFromString;
     readonly error: never;
     readonly config: Omit<{
-        success: S.NumberFromString;
+        success: S.FiniteFromString;
     }, "success" | "error">;
     readonly "~decodingServices": never;
+    readonly "~encodingServices": never;
 };
 export declare class GetSomething2 extends GetSomething2_base {
 }
-declare const GetSomething2WithDependencies_base: S.TaggedStruct<"GetSomething2", {
+declare const GetSomething2WithDependencies_base: S.EnhancedClass<GetSomething2WithDependencies, S.TaggedStruct<"GetSomething2", {
     id: S.String;
-}> & {
-    new (...args: any[]): any;
+}>, {}> & {
     readonly _tag: "GetSomething2";
-    readonly fields: {
-        readonly _tag: S.tag<"GetSomething2">;
-    } & {
-        id: S.String;
-    };
     readonly success: S.Codec<number, string, "dep-a", never>;
     readonly error: S.String;
     readonly config: Omit<{
@@ -141,6 +123,7 @@ declare const GetSomething2WithDependencies_base: S.TaggedStruct<"GetSomething2"
         error: S.String;
     }, "success" | "error">;
     readonly "~decodingServices": "dep-a";
+    readonly "~encodingServices": never;
 };
 export declare class GetSomething2WithDependencies extends GetSomething2WithDependencies_base {
 }

package/test/dist/stubs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stubs.d.ts","sourceRoot":"","sources":["../stubs.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,oCAAoC,CAAA;AAE9E,OAAO,EAAU,KAAK,EAA0B,CAAC,EAAE,MAAM,YAAY,CAAA;AACrE,OAAO,EAAE,gBAAgB,EAAiB,MAAM,mBAAmB,CAAA;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAG9C,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AAC5D,OAAO,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAA;AAElD,OAAO,KAAK,KAAK,MAAM,8BAA8B,CAAA;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AAC5D,OAAO,EAAE,cAAc,EAAc,MAAM,sBAAsB,CAAA;AACjE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAA;AA8CxD,eAAO,MAAM,YAAY,GAAI,WAAU,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAM,KAepG,UAAU,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAClD,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,WAAU,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAM,oCACpC,CAAA;AAExE,eAAO,MAAM,eAAe,GAC1B,UAAU;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,GAAG,EAAE,CAAA;CAAE,6GASxG,CAAA;;;;;;;;AAED,qBAAa,iBAAkB,SAAQ,sBAAyB;CAAG;AACnE,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAqC,CAAA;;;;;;;;;;;;;;;;;;AACtE,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;;;;;;;;;;iBAML,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC;;;;;AAJjE,qBAAa,6BAA8B,SAAQ,kCAMjD;CAAG;AAEL,eAAO,MAAM,SAAS;;;;;;CAA+F,CAAA;AAErH,eAAO,MAAM,SAAS,GACpB,UAAU;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,GAAG,EAAE,CAAA;CAAE;;;;;;;;;CAcxG,CAAA"}
+{"version":3,"file":"stubs.d.ts","sourceRoot":"","sources":["../stubs.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,oCAAoC,CAAA;AAE9E,OAAO,EAAU,KAAK,EAA0B,CAAC,EAAE,MAAM,YAAY,CAAA;AACrE,OAAO,EAAE,gBAAgB,EAAiB,MAAM,mBAAmB,CAAA;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAG9C,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AAC5D,OAAO,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAA;AAElD,OAAO,KAAK,KAAK,MAAM,8BAA8B,CAAA;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AAC5D,OAAO,EAAE,cAAc,EAAc,MAAM,sBAAsB,CAAA;AACjE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAA;AA8CxD,eAAO,MAAM,YAAY,GAAI,WAAU,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAM,KAepG,UAAU,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAClD,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,WAAU,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAM,oCACpC,CAAA;AAExE,eAAO,MAAM,eAAe,GAC1B,UAAU;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,GAAG,EAAE,CAAA;CAAE,6GASxG,CAAA;;;;;;;;AAED,qBAAa,iBAAkB,SAAQ,sBAAyB;CAAG;AACnE,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAqC,CAAA;;;;;;;;;;;;;AACtE,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;;;;iBAML,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC;;;;;;AAJjE,qBAAa,6BAA8B,SAAQ,kCAMjD;CAAG;AAEL,eAAO,MAAM,SAAS;;;;;;CAA+F,CAAA;AAErH,eAAO,MAAM,SAAS,GACpB,UAAU;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,GAAG,EAAE,CAAA;CAAE;;;;;;;;;CAcxG,CAAA"}

package/test/dist/stubs.js

@@ -79,13 +79,13 @@ export class RequestContextMap extends RpcContextMap.makeMap({}) {
 export const { TaggedRequest: Req } = makeRpcClient(RequestContextMap);
 export class GetSomething2 extends Req()("GetSomething2", {
     id: S.String
-}, { success: S.NumberFromString }) {
+}, { success: S.FiniteFromString }) {
 }
 export class GetSomething2WithDependencies extends Req()("GetSomething2", {
     id: S.String
 }, {
     // this is intentilally fake, to simulate a codec that requires a dependency
-    success: S.NumberFromString,
+    success: S.FiniteFromString,
     error: S.String
 }) {
 }

package/test/form-validation-errors.test.ts

@@ -4,7 +4,7 @@ import { buildFieldInfoFromFieldsRoot, translate } from "../src/form.js"
 // test schema with integer field
 class TestSchema extends S.Class<TestSchema>("TestSchema")({
   integerField: S.Int,
-  numberField: S.Number,
+  numberField: S.Finite,
   stringField: S.String
 }) {}
 
@@ -137,22 +137,26 @@ it("validates integer field with valid integer", () =>
     .pipe(Effect.runPromise))
 
 it("error message format matches regex pattern", () => {
-  // test the actual error message format from Effect Schema
-  const errorMessage = `Int
-└─ From side refinement failure
-   └─ Int
-      └─ Predicate refinement failure
-         └─ Expected an integer, actual 59.5`
-
-  const integerMatch = errorMessage.match(/Expected.*integer.*actual\s+(.+)/i)
-  expect(integerMatch).toBeTruthy()
-  expect(integerMatch![1]).toBe("59.5")
-
-  const numberErrorMessage = `Number
-└─ Type side transformation failure
-   └─ Expected a number, actual "not-a-number"`
-
-  const numberMatch = numberErrorMessage.match(/Expected.*number.*actual\s+(.+)/i)
-  expect(numberMatch).toBeTruthy()
-  expect(numberMatch![1]).toBe("\"not-a-number\"")
+  // test the actual error message format from Effect Schema (both old "actual" and new "got" formats)
+  const errorMessageOld = `Expected an integer, actual 59.5`
+  const errorMessageNew = `SchemaError(Expected an integer, got 59.5)`
+
+  const oldMatch = errorMessageOld.match(/Expected.*integer.*(?:actual|got)\s+([^)]+)/i)
+  expect(oldMatch).toBeTruthy()
+  expect(oldMatch![1]).toBe("59.5")
+
+  const newMatch = errorMessageNew.match(/Expected.*integer.*(?:actual|got)\s+([^)]+)/i)
+  expect(newMatch).toBeTruthy()
+  expect(newMatch![1]).toBe("59.5")
+
+  const numberErrorOld = `Expected a number, actual "not-a-number"`
+  const numberErrorNew = `SchemaError(Expected a finite number, got "not-a-number")`
+
+  const numOldMatch = numberErrorOld.match(/Expected.*number.*(?:actual|got)\s+([^)]+)/i)
+  expect(numOldMatch).toBeTruthy()
+  expect(numOldMatch![1]).toBe("\"not-a-number\"")
+
+  const numNewMatch = numberErrorNew.match(/Expected.*number.*(?:actual|got)\s+([^)]+)/i)
+  expect(numNewMatch).toBeTruthy()
+  expect(numNewMatch![1]).toBe("\"not-a-number\"")
 })

package/test/stubs.ts

@@ -95,13 +95,13 @@ export class RequestContextMap extends RpcContextMap.makeMap({}) {}
 export const { TaggedRequest: Req } = makeRpcClient(RequestContextMap)
 export class GetSomething2 extends Req<GetSomething2>()("GetSomething2", {
   id: S.String
-}, { success: S.NumberFromString }) {}
+}, { success: S.FiniteFromString }) {}
 
 export class GetSomething2WithDependencies extends Req<GetSomething2WithDependencies>()("GetSomething2", {
   id: S.String
 }, {
   // this is intentilally fake, to simulate a codec that requires a dependency
-  success: S.NumberFromString as S.Codec<number, string, "dep-a">,
+  success: S.FiniteFromString as S.Codec<number, string, "dep-a">,
   error: S.String
 }) {}
 

package/tsconfig.json

@@ -32,7 +32,6 @@
     "outDir": "build/dist",
     "resolveJsonModule": true,
     "moduleResolution": "Node16",
-    "downlevelIteration": true,
     "noErrorTruncation": true,
     "forceConsistentCasingInFileNames": true,
     "types": [