effect-app 4.0.0-beta.21 → 4.0.0-beta.210

package/package.json

@@ -1,31 +1,30 @@
 {
   "name": "effect-app",
-  "version": "4.0.0-beta.21",
+  "version": "4.0.0-beta.210",
   "license": "MIT",
   "type": "module",
   "dependencies": {
     "@tsconfig/strictest": "^2.0.8",
     "date-fns": "^4.1.0",
-    "nanoid": "^5.1.6",
+    "nanoid": "^5.1.11",
     "path-parser": "^6.1.0",
     "query-string": "^9.3.1",
     "ts-pattern": "^5.9.0",
     "ts-toolbelt": "^9.6.0",
-    "uuid": "^13.0.0",
-    "validator": "^13.15.26"
+    "uuid": "^14.0.0",
+    "validator": "^13.15.35"
   },
   "devDependencies": {
     "@faker-js/faker": "^8.4.1",
-    "@types/node": "25.3.3",
+    "@types/node": "25.6.0",
     "@types/uuid": "^11.0.0",
     "@types/validator": "^13.15.10",
-    "fast-check": "~4.5.3",
-    "typescript": "~5.9.3",
-    "vitest": "^4.0.18",
-    "@effect-app/eslint-shared-config": "0.5.7-beta.2"
+    "fast-check": "~4.7.0",
+    "typescript": "~6.0.3",
+    "vitest": "^4.1.5"
   },
   "peerDependencies": {
-    "effect": "^4.0.0-beta.36"
+    "effect": "^4.0.0-beta.62"
   },
   "typesVersions": {
     "*": {
@@ -47,10 +46,22 @@
       "types": "./dist/Chunk.d.ts",
       "default": "./dist/Chunk.js"
     },
+    "./Config": {
+      "types": "./dist/Config.d.ts",
+      "default": "./dist/Config.js"
+    },
     "./Config/SecretURL": {
       "types": "./dist/Config/SecretURL.d.ts",
       "default": "./dist/Config/SecretURL.js"
     },
+    "./ConfigProvider": {
+      "types": "./dist/ConfigProvider.d.ts",
+      "default": "./dist/ConfigProvider.js"
+    },
+    "./Context": {
+      "types": "./dist/Context.d.ts",
+      "default": "./dist/Context.js"
+    },
     "./Effect": {
       "types": "./dist/Effect.d.ts",
       "default": "./dist/Effect.js"
@@ -71,10 +82,6 @@
       "types": "./dist/NonEmptySet.d.ts",
       "default": "./dist/NonEmptySet.js"
     },
-    "./Operations": {
-      "types": "./dist/Operations.d.ts",
-      "default": "./dist/Operations.js"
-    },
     "./Option": {
       "types": "./dist/Option.d.ts",
       "default": "./dist/Option.js"
@@ -99,6 +106,18 @@
       "types": "./dist/Schema/Methods.d.ts",
       "default": "./dist/Schema/Methods.js"
     },
+    "./Schema/SchemaParser": {
+      "types": "./dist/Schema/SchemaParser.d.ts",
+      "default": "./dist/Schema/SchemaParser.js"
+    },
+    "./Schema/SpecialJsonSchema": {
+      "types": "./dist/Schema/SpecialJsonSchema.d.ts",
+      "default": "./dist/Schema/SpecialJsonSchema.js"
+    },
+    "./Schema/SpecialOpenApi": {
+      "types": "./dist/Schema/SpecialOpenApi.d.ts",
+      "default": "./dist/Schema/SpecialOpenApi.js"
+    },
     "./Schema/brand": {
       "types": "./dist/Schema/brand.d.ts",
       "default": "./dist/Schema/brand.js"
@@ -131,10 +150,6 @@
       "types": "./dist/Schema/strings.d.ts",
       "default": "./dist/Schema/strings.js"
     },
-    "./ServiceMap": {
-      "types": "./dist/ServiceMap.d.ts",
-      "default": "./dist/ServiceMap.js"
-    },
     "./Set": {
       "types": "./dist/Set.d.ts",
       "default": "./dist/Set.js"
@@ -175,6 +190,10 @@
       "types": "./dist/client.d.ts",
       "default": "./dist/client.js"
     },
+    "./client/InvalidationKeys": {
+      "types": "./dist/client/InvalidationKeys.d.ts",
+      "default": "./dist/client/InvalidationKeys.js"
+    },
     "./client/apiClientFactory": {
       "types": "./dist/client/apiClientFactory.d.ts",
       "default": "./dist/client/apiClientFactory.js"
@@ -219,6 +238,10 @@
       "types": "./dist/rpc.d.ts",
       "default": "./dist/rpc.js"
     },
+    "./rpc/Invalidation": {
+      "types": "./dist/rpc/Invalidation.d.ts",
+      "default": "./dist/rpc/Invalidation.js"
+    },
     "./rpc/MiddlewareMaker": {
       "types": "./dist/rpc/MiddlewareMaker.d.ts",
       "default": "./dist/rpc/MiddlewareMaker.js"
@@ -280,20 +303,19 @@
   "scripts": {
     "watch": "pnpm build:tsc -w",
     "build:tsc": "pnpm clean-dist && effect-app-cli packagejson && pnpm check",
-    "check": "tsc --build",
+    "check": "tsgo --build",
     "build:tsc-src": "pnpm clean-dist && effect-app-cli packagejson tsc --build ./tsconfig.src.json",
     "build:src": "pnpm build:tsc-src",
     "build": "pnpm build:tsc",
-    "watch2": "pnpm clean-dist && NODE_OPTIONS=--max-old-space-size=6144 tsc -w",
+    "watch2": "pnpm clean-dist && NODE_OPTIONS=--max-old-space-size=6144 tsgo -w",
     "clean": "rm -rf dist",
     "clean-dist": "sh ../../scripts/clean-dist.sh",
     "circular": "pnpm circular:src && pnpm circular:dist",
     "circular:src": "madge --circular --ts-config ./tsconfig.json --extensions ts ./src",
     "circular:dist": "madge --circular --extensions js ./dist",
-    "compile": "NODE_OPTIONS=--max-old-space-size=6144 tsc --noEmit",
-    "lint": "NODE_OPTIONS=--max-old-space-size=6144 ESLINT_TS=1 eslint ./src",
-    "lint:watch": "ESLINT_TS=1 esw -w --changed --clear --ext ts,tsx .",
-    "lint-fix": "pnpm lint --fix",
+    "compile": "NODE_OPTIONS=--max-old-space-size=6144 tsgo --noEmit",
+    "lint": "oxlint --type-aware ./src && pnpm exec dprint check --config ../../dprint.jsonc .",
+    "lint-fix": "oxlint --type-aware --fix ./src && pnpm exec dprint fmt --config ../../dprint.jsonc .",
     "test": "vitest",
     "test:run": "pnpm run test run --passWithNoTests",
     "testsuite": "pnpm lint && pnpm circular && pnpm run test:run",

package/src/Config/SecretURL.ts

@@ -21,6 +21,7 @@ import * as internal from "./internal/configSecretURL.js"
  * @since 1.0.0
  * @category models
  */
+// eslint-disable-next-line import/namespace
 export interface SecretURL extends Redacted.Redacted, Equal.Equal {
   /** @internal */
   readonly raw: Array<number>
@@ -73,5 +74,5 @@ export const value: (self: SecretURL) => string = internal.value
 export const unsafeWipe: (self: SecretURL) => void = internal.unsafeWipe
 
 export const secretURL = (name?: string): Config.Config<SecretURL> => {
-  return Config.map(Config.string(name), fromString)
+  return Config.map(Config.nonEmptyString(name), fromString)
 }

package/src/Config.ts

@@ -0,0 +1,14 @@
+import { type Config, make } from "effect/Config"
+import { dual } from "effect/Function"
+
+import * as ConfigProvider from "./ConfigProvider.js"
+
+export const nested: {
+  (name: string): <A>(self: Config<A>) => Config<A>
+  <A>(self: Config<A>, name: string): Config<A>
+} = dual(
+  2,
+  <A>(self: Config<A>, name: string): Config<A> => make((provider) => self.parse(ConfigProvider.nested(provider, name)))
+)
+
+export * from "effect/Config"

package/src/ConfigProvider.ts

@@ -0,0 +1,48 @@
+import { type ConfigProvider, make, type Path } from "effect/ConfigProvider"
+import { dual } from "effect/Function"
+
+/**
+ * Scopes a provider so that all lookups are prefixed with the given path
+ * segments.
+ *
+ * When to use:
+ * - Namespacing config under a prefix like `"app"` or `"database"`.
+ * - Reusing the same provider shape for multiple sub-configs.
+ *
+ * Accepts a single string or a full `Path` array. The prefix is prepended
+ * *after* any `mapInput` transformation runs, so ordering matters when
+ * composing with {@link mapInput} or {@link constantCase}.
+ *
+ * Supports both data-last and data-first calling conventions.
+ *
+ * **Example** (Nesting under a prefix)
+ *
+ * ```ts
+ * import { ConfigProvider } from "effect"
+ *
+ * const provider = ConfigProvider.fromEnv({
+ *   env: { APP_HOST: "localhost", APP_PORT: "3000" }
+ * })
+ *
+ * // Lookups for ["HOST"] now resolve to ["APP", "HOST"]
+ * const scoped = ConfigProvider.nested(provider, "APP")
+ * ```
+ *
+ * @see {@link mapInput} – for arbitrary path transformations
+ *
+ * @category Combinators
+ * @since 4.0.0
+ */
+export const nested: {
+  (prefix: string | Path): (self: ConfigProvider) => ConfigProvider
+  (self: ConfigProvider, prefix: string | Path): ConfigProvider
+} = dual(
+  2,
+  (self: ConfigProvider, prefix: string | Path): ConfigProvider => {
+    let path: Path = typeof prefix === "string" ? [prefix] : prefix
+    if (self.mapInput) path = self.mapInput(path)
+    return make(self.get, self.mapInput, self.prefix ? [...self.prefix, ...path] : path)
+  }
+)
+
+export * from "effect/ConfigProvider"

package/src/{ServiceMap.ts → Context.ts}

@@ -1,21 +1,17 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * We're doing the long way around here with assignTag, TagBase & TagBaseTagged,
- * because there's a typescript compiler issue where it will complain about Equal.symbol, and Hash.symbol not being accessible.
- * https://github.com/microsoft/TypeScript/issues/52644
- */
+/* eslint-disable import/namespace */
 
 import { type Effect, Layer, type Scope, type Types } from "effect"
-import * as ServiceMap from "effect/ServiceMap"
+import * as CTX from "effect/Context"
 import { type Yieldable } from "./Effect.js"
 
-export * from "effect/ServiceMap"
+export * from "effect/Context"
 
 export interface Opaque<Self extends object, in out Shape extends object>
-  extends ServiceMap.Key<Self, Self>, Yieldable<Opaque<Self, Shape>, Self, never, Self>
+  extends CTX.Key<Self, Self>, Yieldable<Opaque<Self, Shape>, Self, never, Self>
 {
   of(this: void, self: Shape): Self
-  serviceMap(self: Shape): ServiceMap.ServiceMap<Self>
+  context(self: Shape): CTX.Context<Self>
   // a version that leverages the Shape -> Self conversion
   toLayer: <E, R>(
     eff: Effect.Effect<Shape, E, R>
@@ -25,11 +21,11 @@ export interface Opaque<Self extends object, in out Shape extends object>
 }
 
 // export interface OpaqueMake<Self extends object, in out Shape extends object, E, R>
-//   extends ServiceMap.Service<Self, Self>
+//   extends CTX.Service<Self, Self>
 // {
 //   // temp while sorting out https://github.com/Effect-TS/effect-smol/pull/1534
 //   of(self: Shape): Self
-//   serviceMap2(self: Shape): ServiceMap.ServiceMap<Self>
+//   contextMap2(self: Shape): CTX.Context<Self>
 //   // a version that leverages the Shape -> Self conversion
 //   toLayer: {
 //     <E, R>(
@@ -44,7 +40,7 @@ export function assignTag<Identifier extends object, Shape extends object = Iden
   creationError?: Error
 ) {
   return <S extends object>(cls: S): S & Opaque<Identifier, Shape> => {
-    const tag = ServiceMap.Service<Identifier, Shape>(key)
+    const tag = CTX.Service<Identifier, Shape>(key)
     let fields = tag
     if (Reflect.ownKeys(cls).includes("key")) {
       const { key, ...rest } = tag
@@ -67,54 +63,51 @@ export function assignTag<Identifier extends object, Shape extends object = Iden
   }
 }
 
-export type ServiceAcessorShape<Self, Type> = Type extends Record<PropertyKey, any> ? {
-    [
-      k in keyof Type as Type[k] extends ((...args: [...infer Args]) => infer Ret)
-        ? ((...args: Readonly<Args>) => Ret) extends Type[k] ? k : never
-        : k
-    ]: Type[k] extends (...args: [...infer Args]) => Effect.Effect<infer A, infer E, infer R>
-      ? (...args: Readonly<Args>) => Effect.Effect<A, E, Self | R>
-      : Type[k] extends (...args: [...infer Args]) => infer A
-        ? (...args: Readonly<Args>) => Effect.Effect<A, never, Self>
-      : Type[k] extends Effect.Effect<infer A, infer E, infer R> ? Effect.Effect<A, E, Self | R>
-      : Effect.Effect<Type[k], never, Self>
-  }
-  : {}
+/** Accessor for a service method that returns a plain value. Wraps via `useSync`. */
+export const accessFn = <
+  Self extends object,
+  Shape extends Record<PropertyKey, any>,
+  K extends keyof Shape
+>(
+  Tag: Opaque<Self, Shape>,
+  key: K
+): Shape[K] extends (...args: [...infer Args]) => infer A ? (...args: Readonly<Args>) => Effect.Effect<A, never, Self>
+  : never => ((...args: Array<any>) => Tag.useSync((s: any) => s[key](...args))) as any
 
-/**
- * Only use this in very specific cases where using dependencies directly is prefered, like inside command handlers.
- */
-export const proxify = <T extends object>(Tag: T) =>
-<Self, Shape>():
-  & T
-  & ServiceAcessorShape<Self, Shape> =>
-{
-  const cache = new Map()
-  const done = new Proxy(Tag, {
-    get(_target: any, prop: any, _receiver) {
-      if (prop === "use") {
-        // @ts-expect-error abc
-        return (body) => (Tag as any).use(body)
-      }
-      if (prop in Tag) {
-        return (Tag as any)[prop]
-      }
-      if (cache.has(prop)) {
-        return cache.get(prop)
-      }
-      const fn = (...args: Array<any>) => (Tag as any).use((s: any) => s[prop](...args))
-      const cn = (Tag as any).use((s: any) => s[prop])
-      // @effect-diagnostics effect/floatingEffect:off
-      Object.assign(fn, cn)
-      Object.setPrototypeOf(fn, Object.getPrototypeOf(cn))
-      cache.set(prop, fn)
-      return fn
-    }
-  })
-  return done
-}
+/** Accessor for a service method that returns an Effect. Delegates via `use`. */
+export const accessEffectFn = <
+  Self extends object,
+  Shape extends Record<PropertyKey, any>,
+  K extends keyof Shape
+>(
+  Tag: Opaque<Self, Shape>,
+  key: K
+): Shape[K] extends (...args: [...infer Args]) => Effect.Effect<infer A, infer E, infer R>
+  ? (...args: Readonly<Args>) => Effect.Effect<A, E, Self | R>
+  : never => ((...args: Array<any>) => Tag.use((s: any) => s[key](...args))) as any
+
+/** Accessor for a service property (constant). Wraps via `useSync`. */
+export const accessCn = <
+  Self extends object,
+  Shape extends Record<PropertyKey, any>,
+  K extends keyof Shape
+>(
+  Tag: Opaque<Self, Shape>,
+  key: K
+): Effect.Effect<Shape[K], never, Self> => Tag.useSync((s) => s[key])
+
+/** Accessor for a service property that is an Effect. Delegates via `use`. */
+export const accessEffectCn = <
+  Self extends object,
+  Shape extends Record<PropertyKey, any>,
+  K extends keyof Shape
+>(
+  Tag: Opaque<Self, Shape>,
+  key: K
+): Shape[K] extends Effect.Effect<infer A, infer E, infer R> ? Effect.Effect<A, E, Self | R>
+  : never => Tag.use((s: any) => s[key]) as any
 
-export const TypeId = "~ServiceMap.Opaque"
+export const TypeId = "~Context.Opaque"
 
 // export function Opaque<const Key extends string>(key: Key) {
 //   return <Identifier extends object, Shape extends object>() => {
@@ -179,7 +172,7 @@ export const Opaque: {
     >
     & { readonly make: Make }
 } = () => (id: string, options: any) => {
-  const svc = ServiceMap.Service()(id, options) as any
+  const svc = CTX.Service()(id, options) as any
   return Object.assign(svc, {
     toLayer: (eff: Effect.Effect<any, any, any>) => {
       return Layer.effect(svc, eff)

package/src/Effect.ts

@@ -2,11 +2,11 @@
 /* eslint-disable prefer-destructuring */
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 
-import { Effect, Option, Ref, type ServiceMap } from "effect"
+import { Effect, Option, Ref } from "effect"
 import * as Def from "effect/Deferred"
-import * as Fiber from "effect/Fiber"
 import type { Scope } from "effect/Scope"
 import type { Semaphore } from "effect/Semaphore"
+import type * as Context from "./Context.js"
 import { curry } from "./Function.js"
 import { typedKeysOf } from "./utils.js"
 
@@ -111,15 +111,11 @@ export function modifyWithPermitWithEffect<A>(ref: Ref.Ref<A>, semaphore: Semaph
     )
 }
 
-export function joinAll<E, A>(fibers: Iterable<Fiber.Fiber<A, E>>): Effect.Effect<readonly A[], E> {
-  return Fiber.joinAll(fibers) as any
-}
-
 type ServiceA<T> = T extends Effect.Effect<infer S, any, any> ? S
-  : T extends ServiceMap.Service<any, infer S> ? S
+  : T extends Context.Service<any, infer S> ? S
   : never
 type ServiceR<T> = T extends Effect.Effect<any, any, infer R> ? R
-  : T extends ServiceMap.Service<infer I, any> ? I
+  : T extends Context.Service<infer I, any> ? I
   : never
 type ServiceE<T> = T extends Effect.Effect<any, infer E, any> ? E : never
 // type Values<T> = T extends { [s: string]: infer S } ? ServiceA<S> : never
@@ -140,28 +136,30 @@ type ValuesE<T> = T extends { [s: string]: infer S } ? ServiceE<S> : never
  * const b = a({ str: "" })   // valid, but shouldn't be!
  * ```
  */
+// eslint-disable-next-line import/namespace
 export interface EffectUnunified<R, E, A> extends Effect.Effect<R, E, A> {}
 
 export type LowerFirst<S extends PropertyKey> = S extends `${infer First}${infer Rest}` ? `${Lowercase<First>}${Rest}`
   : S
-export type LowerServices<T extends Record<string, ServiceMap.Service<any, any> | Effect.Effect<any, any, any>>> = {
+export type LowerServices<T extends Record<string, Context.Service<any, any> | Effect.Effect<any, any, any>>> = {
   [key in keyof T as LowerFirst<key>]: ServiceA<T[key]>
 }
 
-export function allLower<T extends Record<string, ServiceMap.Service<any, any> | Effect.Effect<any, any, any>>>(
+export function allLower<T extends Record<string, Context.Service<any, any> | Effect.Effect<any, any, any>>>(
   services: T
 ) {
   return Effect.all(
     typedKeysOf(services).reduce((prev, cur) => {
-      const svc = services[cur]
-      prev[((cur as string)[0]!.toLowerCase() + (cur as string).slice(1)) as unknown as LowerFirst<typeof cur>] = svc // "_id" in svc && svc._id === TagTypeId ? svc : svc
+      const svc = services[cur]!
+      prev[((cur as string)[0]!.toLowerCase() + (cur as string).slice(1)) as unknown as LowerFirst<typeof cur>] =
+        "asEffect" in svc ? svc.asEffect() : svc
       return prev
     }, {} as any),
     { concurrency: "inherit" }
   ) as any as Effect.Effect<LowerServices<T>, ValuesE<T>, ValuesR<T>>
 }
 
-export function allLowerWith<T extends Record<string, ServiceMap.Service<any, any> | Effect.Effect<any, any, any>>, A>(
+export function allLowerWith<T extends Record<string, Context.Service<any, any> | Effect.Effect<any, any, any>>, A>(
   services: T,
   fn: (services: LowerServices<T>) => A
 ) {
@@ -169,7 +167,7 @@ export function allLowerWith<T extends Record<string, ServiceMap.Service<any, an
 }
 
 export function allLowerWithEffect<
-  T extends Record<string, ServiceMap.Service<any, any> | Effect.Effect<any, any, any>>,
+  T extends Record<string, Context.Service<any, any> | Effect.Effect<any, any, any>>,
   R,
   E,
   A

package/src/Layer.ts

@@ -1,6 +1,7 @@
-import { type Array, Effect, Layer, type Scope, type ServiceMap, type Types } from "effect"
+import { type Array, Effect, Layer, type Scope, type Types } from "effect"
 import { type Yieldable } from "effect/Effect"
 import { dual } from "effect/Function"
+import type * as Context from "./Context.js"
 import { type EffectGenUtils } from "./utils/gen.js"
 
 export * from "effect/Layer"
@@ -11,13 +12,13 @@ type MakeEff<S, E, R> = {
   readonly make: Effect.Effect<S, E, R>
 }
 type MakeGen<S, E = never, R = never> = {
-  readonly make: () => Generator<Yieldable<any, any, E, R>, S, any>
+  readonly make: () => Generator<Yieldable<any, any, E, R>, S>
 }
 type MakeGenNo<S> = {
   readonly make: () => Generator<unknown, S>
 }
 type MakeErr<Opts> = Opts extends { make: () => any } ? EffectGenUtils.Error<Opts["make"]> : never
-type MakeContext<Opts> = Opts extends { make: () => any } ? EffectGenUtils.ServiceMap<Opts["make"]> : never
+type MakeContext<Opts> = Opts extends { make: () => any } ? EffectGenUtils.Context<Opts["make"]> : never
 
 type DependenciesOpt = { dependencies?: Array.NonEmptyReadonlyArray<Layer.Any> }
 type Dependencies = { dependencies: Array.NonEmptyReadonlyArray<Layer.Any> }
@@ -41,12 +42,12 @@ type PackedOrUnpackedLayer<I, Opts> = Opts extends Dependencies ? PackedLayers<I
 
 export const make: {
   <I, S>(
-    tag: ServiceMap.Service<I, S>
+    tag: Context.Service<I, S>
   ): <Opts extends Make<Types.NoInfer<S>, any, any>>(
     options: Opts
   ) => PackedOrUnpackedLayer<I, Opts>
   <I, S, Opts extends Make<Types.NoInfer<S>, any, any>>(
-    tag: ServiceMap.Service<I, S>,
+    tag: Context.Service<I, S>,
     options: Opts
   ): PackedOrUnpackedLayer<I, Opts>
 } = dual(2, (tag, options) => {

package/src/Pure.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Chunk, Effect, Layer, Result } from "effect"
+import * as Context from "./Context.js"
 import { tuple } from "./Function.js"
-import * as ServiceMap from "./ServiceMap.js"
 
 const S1 = Symbol()
 const S2 = Symbol()
@@ -86,9 +86,9 @@ export function GMU<W, S, S2, GA, MR, ME>(modify: (i: GA) => Pure<W, S, S2, MR,
   ) => GMU_(get, modify, update)
 }
 
-const tagg = ServiceMap.Service<{ env: PureEnv<never, unknown, never> }>("PureEnv")
+const tagg = Context.Service<{ env: PureEnv<never, unknown, never> }>("PureEnv")
 function castTag<W, S, S2>() {
-  return tagg as any as ServiceMap.Service<PureEnvEnv<W, S, S2>, PureEnvEnv<W, S, S2>>
+  return tagg as any as Context.Service<PureEnvEnv<W, S, S2>, PureEnvEnv<W, S, S2>>
 }
 
 export const ServiceTag = Symbol()
@@ -100,9 +100,9 @@ export abstract class PhantomTypeParameter<Identifier extends keyof any, Instant
   }
 }
 
-export type ServiceShape<T extends ServiceMap.ServiceClass.Shape<any, any>> = Omit<
+export type ServiceShape<T extends Context.ServiceClass.Shape<any, any>> = Omit<
   T,
-  keyof ServiceMap.ServiceClass.Shape<any, any>
+  keyof Context.ServiceClass.Shape<any, any>
 >
 
 export abstract class ServiceTagged<ServiceKey> extends PhantomTypeParameter<string, ServiceKey> {}
@@ -117,11 +117,11 @@ export interface PureEnvEnv<W, S, S2> extends ServiceTagged<typeof PureEnvEnv> {
 }
 
 export function get<S>(): Pure<never, S, S, never, never, S> {
-  return (castTag<never, S, S>() as any).use((_: any) => _.env.state)
+  return (castTag<never, S, S>()).useSync((_) => _.env.state)
 }
 
 export function set<S>(s: S): Pure<never, S, S, never, never, void> {
-  return (castTag<never, S, S>() as any).use((_: any) => {
+  return (castTag<never, S, S>()).useSync((_) => {
     _.env.state = s
   })
 }
@@ -129,13 +129,13 @@ export function set<S>(s: S): Pure<never, S, S, never, never, void> {
 export type PureLogT<W> = Pure<W, unknown, never, never, never, void>
 
 export function log<W>(w: W): PureLogT<W> {
-  return (castTag<W, unknown, never>() as any).use((_: any) => {
+  return (castTag<W, unknown, never>()).useSync((_) => {
     _.env.log = Chunk.append(_.env.log, w)
   })
 }
 
 export function logMany<W>(w: Iterable<W>): PureLogT<W> {
-  return (castTag<W, unknown, never>() as any).use((_: any) => {
+  return (castTag<W, unknown, never>()).useSync((_) => {
     _.env.log = Chunk.appendAll(_.env.log, Chunk.fromIterable(w))
   })
 }
@@ -150,17 +150,16 @@ export function runAll<R, E, A, W3, S1, S3, S4 extends S1>(
 > {
   const a = Effect
     .flatMap(self, (x) =>
-      (castTag<W3, S1, S3>() as any)
-        .use(
-          ({ env: _ }: any) => Effect.sync(() => ({ log: _.log, state: _.state }))
+      (castTag<W3, S1, S3>())
+        .useSync(
+          ({ env: _ }) => ({ log: _.log, state: _.state })
         )
         .pipe(
-          Effect.flatMap((_: any) => Effect.succeed(_)),
           Effect.map(
-            ({ log, state }: any) => tuple(log, Result.succeed(tuple(state, x)))
+            ({ log, state }) => tuple(log, Result.succeed(tuple(state, x)))
           )
         ))
-    .pipe(Effect.catch((err: any) => (tagg as any).use((env: any) => tuple(env.env.log, Result.fail(err)))))
+    .pipe(Effect.catch((err: any) => tagg.useSync((env) => tuple(env.env.log, Result.fail(err)))))
   return Effect.provide(a, Layer.succeed(tagg, { env: makePureEnv<W3, S3, S4>(s) as any }) as any) as any
 }
 
@@ -198,11 +197,11 @@ export function runA<R, E, A, W3, S1, S3, S4 extends S1>(
 export function modify<S2, A, S3>(
   mod: (s: S2) => readonly [S3, A]
 ): Effect.Effect<A, never, { env: PureEnv<never, S2, S3> }> {
-  return (castTag<never, S3, S2>() as any).use((_: any) => {
+  return (castTag<never, S3, S2>()).useSync((_) => {
     const [s, a] = mod(_.env.state)
     _.env.state = s as any
     return a
-  })
+  }) as any
 }
 
 export function modifyM<W, R, E, A, S2, S3>(
@@ -210,7 +209,7 @@ export function modifyM<W, R, E, A, S2, S3>(
 ): Effect.Effect<A, E, FixEnv<R, W, S2, S3>> {
   // return serviceWithEffect(_ => Ref.modifyM_(_.state, mod))
   return Effect.flatMap(
-    (castTag<W, S3, S2>() as any).use((_: any) => _),
+    (castTag<W, S3, S2>()).useSync((_) => _),
     (_: any) =>
       Effect.map(mod(_.env.state), ([s, a]: any) => {
         _.env.state = s