effect-app 4.0.0-beta.220 → 4.0.0-beta.221

package/src/Schema/Class.ts

@@ -1,6 +1,10 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { type Cause, Effect, Option, Schema, SchemaAST, SchemaIssue } from "effect"
+import type * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
 import * as S from "effect/Schema"
+import * as SchemaAST from "effect/SchemaAST"
+import * as SchemaIssue from "effect/SchemaIssue"
 import { copyOrigin } from "../utils.js"
 import { concurrencyUnbounded } from "./ext.js"
 import * as SchemaParser from "./SchemaParser.js"
@@ -49,11 +53,11 @@ export type Class<Self, S extends S.Top & { readonly fields: S.Struct.Fields },
  */
 function makeRelaxedDeclaration(
   ast: SchemaAST.Declaration,
-  fields: Schema.Struct.Fields,
+  fields: S.Struct.Fields,
   cls: any
 ): SchemaAST.Declaration {
   const parseOptions = ast.annotations?.["parseOptions"] as SchemaAST.ParseOptions | undefined
-  const structSchema = Schema.Struct(fields)
+  const structSchema = S.Struct(fields)
   const annotatedStruct = parseOptions ? S.toType(structSchema).annotate({ parseOptions }) : S.toType(structSchema)
   const decodeStruct = SchemaParser.decodeUnknownEffect(annotatedStruct)
 
@@ -86,7 +90,7 @@ function makeRelaxedDeclaration(
  *
  * @example
  * ```ts
- * import { Schema } from "effect"
+ * import * as Schema from "effect/Schema"
  * import { Class } from "./Class.js"
  *
  * class A extends Class<A>("A")({ a: Schema.String }) {}
@@ -155,7 +159,7 @@ export const Class: <Self = never, Encoded = ExtendedSchemaNoEncoded, Brand = {}
  *
  * @example
  * ```ts
- * import { Schema } from "effect"
+ * import * as Schema from "effect/Schema"
  * import { TaggedClass } from "./Class.js"
  *
  * class Circle extends TaggedClass<Circle>()("Circle", {

package/src/Schema/SpecialJsonSchema.ts

@@ -2,7 +2,9 @@
  * SpecialJsonSchema — A variant of Schema.toJsonSchemaDocument that
  * post-processes the output (e.g. flattens simple allOf).
  */
-import { type JsonSchema, type Schema, SchemaRepresentation } from "effect"
+import type * as JsonSchema from "effect/JsonSchema"
+import type * as Schema from "effect/Schema"
+import * as SchemaRepresentation from "effect/SchemaRepresentation"
 
 /**
  * Converts a schema to a JSON Schema Document (draft-2020-12), with

package/src/Schema/brand.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
-import type { Option } from "effect"
 import * as B from "effect/Brand"
+import type * as Option from "effect/Option"
 import type * as Result from "effect/Result"
 import * as S from "effect/Schema"
 

package/src/Schema/ext.ts

@@ -30,9 +30,16 @@
  * is gated on an explicit version marker) over shoving missing fields under
  * the rug with a decode-time default.
  */
-import { Config, Effect, Function, Option, pipe, type SchemaAST, SchemaIssue, SchemaTransformation } from "effect"
+import * as Config from "effect/Config"
+import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
+import * as Function from "effect/Function"
+import * as Option from "effect/Option"
 import * as S from "effect/Schema"
 import { isDateValid } from "effect/Schema"
+import type * as SchemaAST from "effect/SchemaAST"
+import * as SchemaIssue from "effect/SchemaIssue"
+import * as SchemaTransformation from "effect/SchemaTransformation"
 import { type NonEmptyReadonlyArray } from "../Array.js"
 import * as Context from "../Context.js"
 import { extendM, typedKeysOf } from "../utils.js"

package/src/Schema/moreStrings.ts

@@ -8,9 +8,10 @@
  * For persisted data, prefer an explicit, preferably versioned migration
  * over decode-time fallbacks. See `./ext.ts` for the full policy note.
  */
-import { Effect, pipe } from "effect"
 import type { Refinement } from "effect-app/Function"
 import { extendM } from "effect-app/utils"
+import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
 import * as S from "effect/Schema"
 import type { Simplify } from "effect/Types"
 import { customRandom, nanoid, urlAlphabet } from "nanoid"

package/src/Schema/numbers.ts

@@ -8,8 +8,8 @@
  * For persisted data, prefer an explicit, preferably versioned migration
  * over decode-time fallbacks. See `./ext.ts` for the full policy note.
  */
-import { Effect } from "effect"
 import { extendM } from "effect-app/utils"
+import * as Effect from "effect/Effect"
 import * as S from "effect/Schema"
 import type { Simplify } from "effect/Types"
 import { fromBrand, nominal } from "./brand.js"

package/src/Schema.ts

@@ -1,6 +1,7 @@
-import { SchemaAST, type Tracer } from "effect"
 import * as S from "effect/Schema"
+import * as SchemaAST from "effect/SchemaAST"
 import { type Simplify } from "effect/Struct"
+import type * as Tracer from "effect/Tracer"
 import type { RequiredKeys } from "effect/Types"
 import type { NonEmptyReadonlyArray } from "./Array.js"
 import { fakerArb } from "./faker.js"
@@ -220,7 +221,7 @@ export interface Struct<Fields extends S.Struct.Fields> extends
    * **Example** (Reusing fields across structs)
    *
    * ```ts
-   * import { Schema } from "effect"
+   * import * as Schema from "effect/Schema"
    *
    * const Timestamped = Schema.Struct({
    *   createdAt: Schema.Date,

package/src/Set.ts

@@ -1,7 +1,11 @@
 // ets_tracing: off
 
-import { Array, type Equivalence, Option, type Order, type Result } from "effect"
+import * as Array from "effect/Array"
+import type * as Equivalence from "effect/Equivalence"
+import * as Option from "effect/Option"
+import type * as Order from "effect/Order"
 import { not } from "effect/Predicate"
+import type * as Result from "effect/Result"
 import { identity, pipe, type Predicate, type Refinement, tuple } from "./Function.js"
 
 export function find_<A, B extends A>(

package/src/_ext/Array.ts

@@ -1,4 +1,6 @@
-import { Chunk, Effect, Equal } from "effect-app"
+import * as Chunk from "effect-app/Chunk"
+import * as Effect from "effect-app/Effect"
+import * as Equal from "effect/Equal"
 import { NotFoundError } from "../client/errors.js"
 
 function getFirstBy<A, Type extends string>(

package/src/_ext/misc.ts

@@ -1,5 +1,8 @@
-import { Effect, Option, Result, type Scope } from "effect"
 import type { LazyArg } from "effect-app/Function"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import * as Result from "effect/Result"
+import type * as Scope from "effect/Scope"
 
 export type _R<T extends Effect.Effect<any, any, any>> = [T] extends [
   Effect.Effect<any, any, infer R>

package/src/_ext/ord.ext.ts

@@ -1,4 +1,5 @@
-import { Chunk, type Equivalence } from "effect"
+import * as Chunk from "effect/Chunk"
+import type * as Equivalence from "effect/Equivalence"
 
 export function toArray<A>(
   gen: Generator<A, void, unknown>

package/src/client/makeClient.ts

@@ -1,5 +1,5 @@
-import { SchemaTransformation } from "effect"
 import type * as Exit from "effect/Exit"
+import * as SchemaTransformation from "effect/SchemaTransformation"
 import { type GetContextConfig, type RpcContextMap } from "../rpc/RpcContextMap.js"
 import * as S from "../Schema.js"
 import { AST } from "../Schema.js"

package/src/http/Request.ts

@@ -1,4 +1,4 @@
-import { Option } from "effect"
+import * as Option from "effect/Option"
 import type { HttpClientResponse } from "effect/unstable/http/HttpClientResponse"
 import * as Effect from "../Effect.js"
 import { HttpClient, HttpClientError, HttpClientRequest, HttpHeaders } from "./internal/lib.js"

package/src/ids.ts

@@ -1,6 +1,6 @@
-import { Effect } from "effect"
 import { brandedStringId, type Codec, NonEmptyString255, StringId, type StringIdBrand, withDefaultMake } from "effect-app/Schema"
 import type { B } from "effect-app/Schema/schema"
+import * as Effect from "effect/Effect"
 import type { Simplify } from "effect/Types"
 import { S } from "./index.js"
 import { extendM } from "./utils.js"

package/src/middleware.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Context } from "effect-app"
+import * as Context from "effect-app/Context"
 import { RpcMiddleware } from "./rpc.js"
 
 export class DevMode extends Context.Reference("DevMode", { defaultValue: () => false }) {}

package/src/rpc/Invalidation.ts

@@ -131,7 +131,7 @@ export interface InvalidationSetService {
  *
  * ```ts
  * import { makeQueryKey } from "effect-app/client"
- * import { Effect } from "effect"
+ * import * as Effect from "effect/Effect"
  * import { Invalidation } from "effect-app/rpc"
  * import * as CartRsc from "../Cart/queries.js"
  * import * as UserRsc from "../User/queries.js"

package/src/rpc/MiddlewareMaker.ts

@@ -1,6 +1,9 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, Layer, type Schema, Schema as S, type Scope } from "effect"
 import { type NonEmptyArray, type NonEmptyReadonlyArray } from "effect/Array"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as S from "effect/Schema"
+import type * as Scope from "effect/Scope"
 import { type Simplify } from "effect/Types"
 import { Rpc, type RpcGroup, type RpcSchema } from "effect/unstable/rpc"
 import { type HandlersFrom } from "effect/unstable/rpc/RpcGroup"
@@ -167,9 +170,9 @@ export interface BuildingMiddleware<
 > {
   rpc: <
     const Tag extends string,
-    Payload extends Schema.Top | Schema.Struct.Fields = typeof Schema.Void,
-    Success extends Schema.Top = typeof Schema.Void,
-    Error extends Schema.Top = typeof Schema.Never,
+    Payload extends S.Top | S.Struct.Fields = typeof S.Void,
+    Success extends S.Top = typeof S.Void,
+    Error extends S.Top = typeof S.Never,
     const Stream extends boolean = false,
     Config extends GetContextConfig<RequestContextMap> = {}
   >(tag: Tag, options?: {
@@ -178,16 +181,16 @@ export interface BuildingMiddleware<
     readonly error?: Error
     readonly stream?: Stream
     readonly config?: Config
-    readonly primaryKey?: [Payload] extends [Schema.Struct.Fields] ? ((
-        payload: Payload extends Schema.Struct.Fields ? Simplify<Schema.Struct<Payload>["Type"]> : Payload["Type"]
+    readonly primaryKey?: [Payload] extends [S.Struct.Fields] ? ((
+        payload: Payload extends S.Struct.Fields ? Simplify<S.Struct<Payload>["Type"]> : Payload["Type"]
       ) => string)
       : never
   }) =>
     & Rpc.Rpc<
       Tag,
-      Payload extends Schema.Struct.Fields ? Schema.Struct<Payload> : Payload,
+      Payload extends S.Struct.Fields ? S.Struct<Payload> : Payload,
       Stream extends true ? RpcSchema.Stream<Success, Error> : Success,
-      Stream extends true ? typeof Schema.Never : Error
+      Stream extends true ? typeof S.Never : Error
     >
     & { readonly config: Config }
 
@@ -313,7 +316,7 @@ const makeMiddlewareBasic = <Self>() =>
   // the rcm config entry pointed at by the middleware's `dynamic.key` (if any).
   // Reason: middlewares declared with `dynamic: RequestContextMap.get("foo")`
   // don't set a static `error` field — at runtime their `.error` defaults to
-  // `Schema.Never`. Without pulling from rcm, the composite middleware's
+  // `S.Never`. Without pulling from rcm, the composite middleware's
   // `.error` collapses to `Never`, and `Rpc.exitSchema` (which walks
   // `rpc.middlewares[*].error` to build the wire failure union) can't decode
   // the actual middleware-thrown error type. Critical for stream rpcs whose
@@ -396,9 +399,9 @@ export const Tag = <Self>() =>
     // rpc with config
     rpc: <
       const Tag extends string,
-      Payload extends Schema.Top | Schema.Struct.Fields = typeof Schema.Void,
-      Success extends Schema.Top = typeof Schema.Void,
-      Error extends Schema.Top = typeof Schema.Never,
+      Payload extends S.Top | S.Struct.Fields = typeof S.Void,
+      Success extends S.Top = typeof S.Void,
+      Error extends S.Top = typeof S.Never,
       const Stream extends boolean = false,
       Config extends GetContextConfig<RequestContextMap["config"]> = {}
     >(tag: Tag, options?: {
@@ -407,17 +410,17 @@ export const Tag = <Self>() =>
       readonly error?: Error
       readonly stream?: Stream
       readonly config?: Config
-      readonly primaryKey?: [Payload] extends [Schema.Struct.Fields] ? ((
-          payload: Payload extends Schema.Struct.Fields ? Simplify<Schema.Struct<Payload>["Type"]> : Payload["Type"]
+      readonly primaryKey?: [Payload] extends [S.Struct.Fields] ? ((
+          payload: Payload extends S.Struct.Fields ? Simplify<S.Struct<Payload>["Type"]> : Payload["Type"]
         ) => string)
         : never
     }):
       & Rpc.Rpc<
         Tag,
-        Payload extends Schema.Struct.Fields ? Schema.Struct<Payload> : Payload,
+        Payload extends S.Struct.Fields ? S.Struct<Payload> : Payload,
         // TODO: enhance `Error`. type based on middleware config.
         Stream extends true ? RpcSchema.Stream<Success, Error> : Success,
-        Stream extends true ? typeof Schema.Never : Error
+        Stream extends true ? typeof S.Never : Error
       >
       & { config: Config } =>
     {

package/src/rpc/RpcContextMap.ts

@@ -2,7 +2,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { type Schema as S } from "effect"
+import type * as S from "effect/Schema"
 import { type AnyWithProps } from "effect/unstable/rpc/Rpc"
 import * as Context from "../Context.js"
 import { type RpcDynamic } from "./RpcMiddleware.js"

package/src/rpc/RpcMiddleware.ts

@@ -1,8 +1,11 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { type Effect, type Schema, type Schema as S, type Scope, type Stream } from "effect"
 import { type NonEmptyReadonlyArray } from "effect/Array"
+import type * as Effect from "effect/Effect"
+import type * as S from "effect/Schema"
+import type * as Scope from "effect/Scope"
+import type * as Stream from "effect/Stream"
 import { type Rpc, RpcMiddleware } from "effect/unstable/rpc"
 import { type TypeId } from "effect/unstable/rpc/RpcMiddleware"
 import type * as Context from "../Context.js"
@@ -12,7 +15,7 @@ export type RpcMiddlewareV4<Provides, E, Requires> = RpcMiddleware.RpcMiddleware
 
 export type RpcOptionsOriginal = {
   readonly optional?: boolean
-  readonly error?: Schema.Top
+  readonly error?: S.Top
   readonly requiredForClient?: boolean
 }
 
@@ -40,7 +43,7 @@ export interface TagClassAny extends RpcMiddleware.AnyService {
   readonly optional: boolean
   readonly provides: any
   readonly requires: any
-  readonly error: Schema.Top
+  readonly error: S.Top
   readonly dynamic?: RpcDynamic<any, any> | undefined
   readonly dependsOn?: NonEmptyReadonlyArray<AnyDynamic> | undefined
 }
@@ -50,18 +53,17 @@ export declare namespace TagClass {
    * @since 1.0.0
    * @category models
    */
-  export type FailureSchema<Options> = Options extends { readonly error: Schema.Top; readonly optional?: false }
+  export type FailureSchema<Options> = Options extends { readonly error: S.Top; readonly optional?: false }
     ? Options["error"]
     // actually not, the Failure depends on Dynamic Middleware Configuration!
     // : Options extends { readonly dynamic: RpcDynamic<any, infer A> } ? A["error"]
-    : typeof Schema.Never
+    : typeof S.Never
 
   /**
    * @since 1.0.0
    * @category models
    */
-  export type Failure<Options> = Options extends { readonly error: Schema.Codec<infer _A>; readonly optional?: false }
-    ? _A
+  export type Failure<Options> = Options extends { readonly error: S.Codec<infer _A>; readonly optional?: false } ? _A
     // actually not, the Failure depends on Dynamic Middleware Configuration!
     : Options extends { readonly dynamic: RpcDynamic<any, infer A> } ? S.Schema.Type<A["error"]>
     : never
@@ -70,7 +72,7 @@ export declare namespace TagClass {
    * @since 1.0.0
    * @category models
    */
-  export type FailureContext<Options> = Schema.Codec.DecodingServices<FailureSchema<Options>>
+  export type FailureContext<Options> = S.Codec.DecodingServices<FailureSchema<Options>>
 
   /**
    * @since 1.0.0

package/src/transform.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Option } from "effect"
 import type { NonEmptyReadonlyArray } from "effect/Array"
+import * as Option from "effect/Option"
 import type { Misc, Union } from "ts-toolbelt"
 import type * as SET from "./Set.js"
 

package/src/utils/effectify.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 
-import { Effect } from "effect"
+import * as Effect from "effect/Effect"
 
 interface Callback<E, A> {
   (err: E, a?: A): void

package/src/utils/logLevel.ts

@@ -1,4 +1,4 @@
-import { type LogLevel } from "effect"
+import type * as LogLevel from "effect/LogLevel"
 
 export const LogLevelToSentry = (level: LogLevel.LogLevel) => {
   switch (level) {

package/src/utils/logger.ts

@@ -1,7 +1,8 @@
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { Effect, type LogLevel } from "effect"
+import * as Effect from "effect/Effect"
+import type * as LogLevel from "effect/LogLevel"
 import * as Context from "../Context.js"
 
 type Levels = "info" | "debug" | "warn" | "error"

package/src/utils.ts

@@ -1,9 +1,14 @@
 /* eslint-disable @typescript-eslint/no-unsafe-function-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-redundant-type-constituents */
-import { Cause, Effect, Exit, Fiber, Option, Record } from "effect"
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as Fiber from "effect/Fiber"
 import { dual } from "effect/Function"
+import * as Option from "effect/Option"
 import { isFunction } from "effect/Predicate"
+import * as Record from "effect/Record"
 import * as Result from "effect/Result"
 import { identity, pipe } from "./Function.js"
 import type { DeepMutable, Equals, Mutable } from "./Types.js"
@@ -874,7 +879,7 @@ const genConstructor = (function*() {}).constructor
 /**
  * @example
  * ```ts
- * import { Utils } from "effect"
+ * import * as Utils from "effect/Utils"
  *
  * function* generatorFn() {
  *   yield 1

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

@@ -1 +1 @@
-{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAErF,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAI0B,KAAK;;;;AAKpC,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}
+{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAErF,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAI0B,KAAK;;;;AAKpC,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}

package/test/moreStrings.test.ts

@@ -1,4 +1,4 @@
-import { S } from "effect-app"
+import * as S from "effect-app/Schema"
 import * as fc from "fast-check"
 import { urlAlphabet } from "nanoid"
 import { test } from "vitest"

package/test/rpc.test.ts

@@ -1,4 +1,5 @@
-import { type Effect, type Option } from "effect"
+import type * as Effect from "effect/Effect"
+import type * as Option from "effect/Option"
 import { expect, test } from "vitest"
 import { makeRpcClient, NotLoggedInError, UnauthorizedError } from "../src/client.js"
 import { ForceVoid } from "../src/client/makeClient.js"

package/test/schema.test.ts

@@ -1,5 +1,6 @@
 // import { generateFromArbitrary } from "@effect-app/infra/test"
-import { Array, S } from "effect-app"
+import * as Array from "effect-app/Array"
+import * as S from "effect-app/Schema"
 import { specialJsonSchemaDocument } from "effect-app/Schema/SpecialJsonSchema"
 import { describe, expect, expectTypeOf, test } from "vitest"
 

package/test/secretURL.test.ts

@@ -1,4 +1,7 @@
-import { Chunk, Config, ConfigProvider, Effect } from "effect"
+import * as Chunk from "effect/Chunk"
+import * as Config from "effect/Config"
+import * as ConfigProvider from "effect/ConfigProvider"
+import * as Effect from "effect/Effect"
 import { describe, expect, test } from "vitest"
 import { fromChunk, fromString, isSecretURL, make, secretURL, unsafeWipe, value } from "../src/Config/SecretURL.js"
 

package/test/special.test.ts

@@ -1,10 +1,13 @@
-import { Option, Predicate, Schema, SchemaGetter } from "effect"
 import { InvalidStateError, LoginError, NotFoundError, NotLoggedInError, OptimisticConcurrencyException, ServiceUnavailableError, UnauthorizedError, ValidationError } from "effect-app/client/errors"
 import * as AppSchema from "effect-app/Schema"
 import { Class } from "effect-app/Schema/Class"
 import { flattenNestedAnyOf, flattenSimpleAllOf, specialJsonSchemaDocument } from "effect-app/Schema/SpecialJsonSchema"
 import { deduplicateOpenApiSchemas } from "effect-app/Schema/SpecialOpenApi"
+import * as Option from "effect/Option"
+import * as Predicate from "effect/Predicate"
+import * as Schema from "effect/Schema"
 import * as S from "effect/Schema"
+import * as SchemaGetter from "effect/SchemaGetter"
 import { describe, expect, it } from "vitest"
 
 describe("Class", () => {

package/test/utils.test.ts

@@ -1,4 +1,4 @@
-import { S } from "effect-app"
+import * as S from "effect-app/Schema"
 import { test } from "vitest"
 import { copyOrigin } from "../src/utils.js"