feat: unwrap InstanceState + EffectBridge namespaces to flat exports + barrel (#22721)

packages/opencode/src/effect/bridge.ts

@@ -5,45 +5,43 @@ import { LocalContext } from "@/util/local-context"
 import { InstanceRef, WorkspaceRef } from "./instance-ref"
 import { attachWith } from "./run-service"
 
-export namespace EffectBridge {
-  export interface Shape {
-    readonly promise: <A, E, R>(effect: Effect.Effect<A, E, R>) => Promise<A>
-    readonly fork: <A, E, R>(effect: Effect.Effect<A, E, R>) => Fiber.Fiber<A, E>
-  }
-
-  function restore<R>(instance: InstanceContext | undefined, workspace: string | undefined, fn: () => R): R {
-    if (instance && workspace !== undefined) {
-      return WorkspaceContext.restore(workspace, () => Instance.restore(instance, fn))
-    }
-    if (instance) return Instance.restore(instance, fn)
-    if (workspace !== undefined) return WorkspaceContext.restore(workspace, fn)
-    return fn()
-  }
-
-  export function make(): Effect.Effect<Shape> {
-    return Effect.gen(function* () {
-      const ctx = yield* Effect.context()
-      const value = yield* InstanceRef
-      const instance =
-        value ??
-        (() => {
-          try {
-            return Instance.current
-          } catch (err) {
-            if (!(err instanceof LocalContext.NotFound)) throw err
-          }
-        })()
-      const workspace = (yield* WorkspaceRef) ?? WorkspaceContext.workspaceID
-      const attach = <A, E, R>(effect: Effect.Effect<A, E, R>) => attachWith(effect, { instance, workspace })
-      const wrap = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-        attach(effect).pipe(Effect.provide(ctx)) as Effect.Effect<A, E, never>
-
-      return {
-        promise: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-          restore(instance, workspace, () => Effect.runPromise(wrap(effect))),
-        fork: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-          restore(instance, workspace, () => Effect.runFork(wrap(effect))),
-      } satisfies Shape
-    })
-  }
+export interface Shape {
+  readonly promise: <A, E, R>(effect: Effect.Effect<A, E, R>) => Promise<A>
+  readonly fork: <A, E, R>(effect: Effect.Effect<A, E, R>) => Fiber.Fiber<A, E>
+}
+
+function restore<R>(instance: InstanceContext | undefined, workspace: string | undefined, fn: () => R): R {
+  if (instance && workspace !== undefined) {
+    return WorkspaceContext.restore(workspace, () => Instance.restore(instance, fn))
+  }
+  if (instance) return Instance.restore(instance, fn)
+  if (workspace !== undefined) return WorkspaceContext.restore(workspace, fn)
+  return fn()
+}
+
+export function make(): Effect.Effect<Shape> {
+  return Effect.gen(function* () {
+    const ctx = yield* Effect.context()
+    const value = yield* InstanceRef
+    const instance =
+      value ??
+      (() => {
+        try {
+          return Instance.current
+        } catch (err) {
+          if (!(err instanceof LocalContext.NotFound)) throw err
+        }
+      })()
+    const workspace = (yield* WorkspaceRef) ?? WorkspaceContext.workspaceID
+    const attach = <A, E, R>(effect: Effect.Effect<A, E, R>) => attachWith(effect, { instance, workspace })
+    const wrap = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+      attach(effect).pipe(Effect.provide(ctx)) as Effect.Effect<A, E, never>
+
+    return {
+      promise: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+        restore(instance, workspace, () => Effect.runPromise(wrap(effect))),
+      fork: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+        restore(instance, workspace, () => Effect.runFork(wrap(effect))),
+    } satisfies Shape
+  })
 }

packages/opencode/src/effect/index.ts

@@ -0,0 +1,2 @@
+export * as InstanceState from "./instance-state"
+export * as EffectBridge from "./bridge"

packages/opencode/src/effect/instance-state.ts

@@ -13,72 +13,70 @@ export interface InstanceState<A, E = never, R = never> {
   readonly cache: ScopedCache.ScopedCache<string, A, E, R>
 }
 
-export namespace InstanceState {
-  export const bind = <F extends (...args: any[]) => any>(fn: F): F => {
-    try {
-      return Instance.bind(fn)
-    } catch (err) {
-      if (!(err instanceof LocalContext.NotFound)) throw err
-    }
-    const fiber = Fiber.getCurrent()
-    const ctx = fiber ? Context.getReferenceUnsafe(fiber.context, InstanceRef) : undefined
-    if (!ctx) return fn
-    return ((...args: any[]) => Instance.restore(ctx, () => fn(...args))) as F
+export const bind = <F extends (...args: any[]) => any>(fn: F): F => {
+  try {
+    return Instance.bind(fn)
+  } catch (err) {
+    if (!(err instanceof LocalContext.NotFound)) throw err
   }
-
-  export const context = Effect.gen(function* () {
-    return (yield* InstanceRef) ?? Instance.current
-  })
-
-  export const workspaceID = Effect.gen(function* () {
-    return (yield* WorkspaceRef) ?? WorkspaceContext.workspaceID
-  })
-
-  export const directory = Effect.map(context, (ctx) => ctx.directory)
-
-  export const make = <A, E = never, R = never>(
-    init: (ctx: InstanceContext) => Effect.Effect<A, E, R | Scope.Scope>,
-  ): Effect.Effect<InstanceState<A, E, Exclude<R, Scope.Scope>>, never, R | Scope.Scope> =>
-    Effect.gen(function* () {
-      const cache = yield* ScopedCache.make<string, A, E, R>({
-        capacity: Number.POSITIVE_INFINITY,
-        lookup: () =>
-          Effect.gen(function* () {
-            return yield* init(yield* context)
-          }),
-      })
-
-      const off = registerDisposer((directory) =>
-        Effect.runPromise(ScopedCache.invalidate(cache, directory).pipe(Effect.provide(EffectLogger.layer))),
-      )
-      yield* Effect.addFinalizer(() => Effect.sync(off))
-
-      return {
-        [TypeId]: TypeId,
-        cache,
-      }
-    })
-
-  export const get = <A, E, R>(self: InstanceState<A, E, R>) =>
-    Effect.gen(function* () {
-      return yield* ScopedCache.get(self.cache, yield* directory)
-    })
-
-  export const use = <A, E, R, B>(self: InstanceState<A, E, R>, select: (value: A) => B) =>
-    Effect.map(get(self), select)
-
-  export const useEffect = <A, E, R, B, E2, R2>(
-    self: InstanceState<A, E, R>,
-    select: (value: A) => Effect.Effect<B, E2, R2>,
-  ) => Effect.flatMap(get(self), select)
-
-  export const has = <A, E, R>(self: InstanceState<A, E, R>) =>
-    Effect.gen(function* () {
-      return yield* ScopedCache.has(self.cache, yield* directory)
-    })
-
-  export const invalidate = <A, E, R>(self: InstanceState<A, E, R>) =>
-    Effect.gen(function* () {
-      return yield* ScopedCache.invalidate(self.cache, yield* directory)
-    })
+  const fiber = Fiber.getCurrent()
+  const ctx = fiber ? Context.getReferenceUnsafe(fiber.context, InstanceRef) : undefined
+  if (!ctx) return fn
+  return ((...args: any[]) => Instance.restore(ctx, () => fn(...args))) as F
 }
+
+export const context = Effect.gen(function* () {
+  return (yield* InstanceRef) ?? Instance.current
+})
+
+export const workspaceID = Effect.gen(function* () {
+  return (yield* WorkspaceRef) ?? WorkspaceContext.workspaceID
+})
+
+export const directory = Effect.map(context, (ctx) => ctx.directory)
+
+export const make = <A, E = never, R = never>(
+  init: (ctx: InstanceContext) => Effect.Effect<A, E, R | Scope.Scope>,
+): Effect.Effect<InstanceState<A, E, Exclude<R, Scope.Scope>>, never, R | Scope.Scope> =>
+  Effect.gen(function* () {
+    const cache = yield* ScopedCache.make<string, A, E, R>({
+      capacity: Number.POSITIVE_INFINITY,
+      lookup: () =>
+        Effect.gen(function* () {
+          return yield* init(yield* context)
+        }),
+    })
+
+    const off = registerDisposer((directory) =>
+      Effect.runPromise(ScopedCache.invalidate(cache, directory).pipe(Effect.provide(EffectLogger.layer))),
+    )
+    yield* Effect.addFinalizer(() => Effect.sync(off))
+
+    return {
+      [TypeId]: TypeId,
+      cache,
+    }
+  })
+
+export const get = <A, E, R>(self: InstanceState<A, E, R>) =>
+  Effect.gen(function* () {
+    return yield* ScopedCache.get(self.cache, yield* directory)
+  })
+
+export const use = <A, E, R, B>(self: InstanceState<A, E, R>, select: (value: A) => B) =>
+  Effect.map(get(self), select)
+
+export const useEffect = <A, E, R, B, E2, R2>(
+  self: InstanceState<A, E, R>,
+  select: (value: A) => Effect.Effect<B, E2, R2>,
+) => Effect.flatMap(get(self), select)
+
+export const has = <A, E, R>(self: InstanceState<A, E, R>) =>
+  Effect.gen(function* () {
+    return yield* ScopedCache.has(self.cache, yield* directory)
+  })
+
+export const invalidate = <A, E, R>(self: InstanceState<A, E, R>) =>
+  Effect.gen(function* () {
+    return yield* ScopedCache.invalidate(self.cache, yield* directory)
+  })