bonecode 1.0.0 → 1.1.0

package/src/engine/effect/bootstrap-runtime.ts

@@ -1,29 +1,29 @@
-import { Layer, ManagedRuntime } from "effect"
-
-import { Plugin } from "@/plugin"
-import { LSP } from "@/lsp/lsp"
-import { FileWatcher } from "@/file/watcher"
-import { Format } from "@/format"
-import { ShareNext } from "@/share/share-next"
-import { File } from "@/file"
-import { Vcs } from "@/project/vcs"
-import { Snapshot } from "@/snapshot"
-import { Bus } from "@/bus"
-import { Config } from "@/config/config"
-import * as Observability from "@opencode-ai/core/effect/observability"
-import { memoMap } from "@opencode-ai/core/effect/memo-map"
-
-export const BootstrapLayer = Layer.mergeAll(
-  Config.defaultLayer,
-  Plugin.defaultLayer,
-  ShareNext.defaultLayer,
-  Format.defaultLayer,
-  LSP.defaultLayer,
-  File.defaultLayer,
-  FileWatcher.defaultLayer,
-  Vcs.defaultLayer,
-  Snapshot.defaultLayer,
-  Bus.defaultLayer,
-).pipe(Layer.provide(Observability.layer))
-
-export const BootstrapRuntime = ManagedRuntime.make(BootstrapLayer, { memoMap })
+import { Layer, ManagedRuntime } from "effect"
+
+import { Plugin } from "@/plugin"
+import { LSP } from "@/lsp/lsp"
+import { FileWatcher } from "@/file/watcher"
+import { Format } from "@/format"
+import { ShareNext } from "@/share/share-next"
+import { File } from "@/file"
+import { Vcs } from "@/project/vcs"
+import { Snapshot } from "@/snapshot"
+import { Bus } from "@/bus"
+import { Config } from "@/config/config"
+import * as Observability from "@opencode-ai/core/effect/observability"
+import { memoMap } from "@opencode-ai/core/effect/memo-map"
+
+export const BootstrapLayer = Layer.mergeAll(
+  Config.defaultLayer,
+  Plugin.defaultLayer,
+  ShareNext.defaultLayer,
+  Format.defaultLayer,
+  LSP.defaultLayer,
+  File.defaultLayer,
+  FileWatcher.defaultLayer,
+  Vcs.defaultLayer,
+  Snapshot.defaultLayer,
+  Bus.defaultLayer,
+).pipe(Layer.provide(Observability.layer))
+
+export const BootstrapRuntime = ManagedRuntime.make(BootstrapLayer, { memoMap })

package/src/engine/effect/bridge.ts

@@ -1,84 +1,84 @@
-import { Context, Effect, Exit, Fiber } from "effect"
-import { WorkspaceContext } from "@/control-plane/workspace-context"
-import type { WorkspaceID } from "@/control-plane/schema"
-import { InstanceRef, WorkspaceRef } from "./instance-ref"
-import { attachWith } from "./run-service"
-
-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>
-  readonly run: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E>
-  readonly bind: <Args extends readonly unknown[], Result>(fn: (...args: Args) => Result) => (...args: Args) => Result
-}
-
-function restoreWorkspace<R>(workspace: WorkspaceID | undefined, fn: () => R): R {
-  if (workspace !== undefined) return WorkspaceContext.restore(workspace, fn)
-  return fn()
-}
-
-function captureSync() {
-  const fiber = Fiber.getCurrent()
-  const instance = fiber ? Context.getReferenceUnsafe(fiber.context, InstanceRef) : undefined
-  const workspace =
-    (fiber ? Context.getReferenceUnsafe(fiber.context, WorkspaceRef) : undefined) ?? WorkspaceContext.workspaceID
-  return { instance, workspace }
-}
-
-export const bind = <Args extends readonly unknown[], Result>(fn: (...args: Args) => Result) => {
-  const captured = captureSync()
-  return (...args: Args) =>
-    restoreWorkspace(captured.workspace, () =>
-      Effect.runSync(
-        attachWith(
-          Effect.sync(() => fn(...args)),
-          captured,
-        ),
-      ),
-    )
-}
-
-/**
- * Bridge from Effect into a Promise-returning JS callback while preserving
- * `WorkspaceContext` AsyncLocalStorage for callback code that still reads it.
- * `InstanceRef` is captured for effects run through the returned bridge APIs;
- * plain JS callbacks that need it should receive the ref explicitly.
- *
- * Mirrors `Effect.promise` but restores workspace ALS first.
- */
-export const fromPromise = <T>(fn: () => Promise<T> | T): Effect.Effect<T> =>
-  Effect.gen(function* () {
-    const workspace = yield* WorkspaceRef
-    return yield* Effect.promise(() => Promise.resolve(restoreWorkspace(workspace, () => fn())))
-  })
-
-export function make(): Effect.Effect<Shape> {
-  return Effect.gen(function* () {
-    const ctx = yield* Effect.context()
-    const captured = captureSync()
-    const instance = (yield* InstanceRef) ?? captured.instance
-    const workspace = (yield* WorkspaceRef) ?? captured.workspace
-    const wrap = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-      attachWith(effect.pipe(Effect.provide(ctx)) as Effect.Effect<A, E, never>, { instance, workspace })
-
-    return {
-      promise: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-        restoreWorkspace(workspace, () => Effect.runPromise(wrap(effect))),
-      fork: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-        restoreWorkspace(workspace, () => Effect.runFork(wrap(effect))),
-      run: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-        Effect.callback<A, E>((resume) => {
-          restoreWorkspace(workspace, () =>
-            Effect.runPromiseExit(wrap(effect)).then((exit) =>
-              resume(Exit.isSuccess(exit) ? Effect.succeed(exit.value) : Effect.failCause(exit.cause)),
-            ),
-          )
-        }),
-      bind:
-        <Args extends readonly unknown[], Result>(fn: (...args: Args) => Result) =>
-        (...args: Args) =>
-          restoreWorkspace(workspace, () => Effect.runSync(wrap(Effect.sync(() => fn(...args))))),
-    } satisfies Shape
-  })
-}
-
-export * as EffectBridge from "./bridge"
+import { Context, Effect, Exit, Fiber } from "effect"
+import { WorkspaceContext } from "@/control-plane/workspace-context"
+import type { WorkspaceID } from "@/control-plane/schema"
+import { InstanceRef, WorkspaceRef } from "./instance-ref"
+import { attachWith } from "./run-service"
+
+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>
+  readonly run: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E>
+  readonly bind: <Args extends readonly unknown[], Result>(fn: (...args: Args) => Result) => (...args: Args) => Result
+}
+
+function restoreWorkspace<R>(workspace: WorkspaceID | undefined, fn: () => R): R {
+  if (workspace !== undefined) return WorkspaceContext.restore(workspace, fn)
+  return fn()
+}
+
+function captureSync() {
+  const fiber = Fiber.getCurrent()
+  const instance = fiber ? Context.getReferenceUnsafe(fiber.context, InstanceRef) : undefined
+  const workspace =
+    (fiber ? Context.getReferenceUnsafe(fiber.context, WorkspaceRef) : undefined) ?? WorkspaceContext.workspaceID
+  return { instance, workspace }
+}
+
+export const bind = <Args extends readonly unknown[], Result>(fn: (...args: Args) => Result) => {
+  const captured = captureSync()
+  return (...args: Args) =>
+    restoreWorkspace(captured.workspace, () =>
+      Effect.runSync(
+        attachWith(
+          Effect.sync(() => fn(...args)),
+          captured,
+        ),
+      ),
+    )
+}
+
+/**
+ * Bridge from Effect into a Promise-returning JS callback while preserving
+ * `WorkspaceContext` AsyncLocalStorage for callback code that still reads it.
+ * `InstanceRef` is captured for effects run through the returned bridge APIs;
+ * plain JS callbacks that need it should receive the ref explicitly.
+ *
+ * Mirrors `Effect.promise` but restores workspace ALS first.
+ */
+export const fromPromise = <T>(fn: () => Promise<T> | T): Effect.Effect<T> =>
+  Effect.gen(function* () {
+    const workspace = yield* WorkspaceRef
+    return yield* Effect.promise(() => Promise.resolve(restoreWorkspace(workspace, () => fn())))
+  })
+
+export function make(): Effect.Effect<Shape> {
+  return Effect.gen(function* () {
+    const ctx = yield* Effect.context()
+    const captured = captureSync()
+    const instance = (yield* InstanceRef) ?? captured.instance
+    const workspace = (yield* WorkspaceRef) ?? captured.workspace
+    const wrap = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+      attachWith(effect.pipe(Effect.provide(ctx)) as Effect.Effect<A, E, never>, { instance, workspace })
+
+    return {
+      promise: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+        restoreWorkspace(workspace, () => Effect.runPromise(wrap(effect))),
+      fork: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+        restoreWorkspace(workspace, () => Effect.runFork(wrap(effect))),
+      run: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+        Effect.callback<A, E>((resume) => {
+          restoreWorkspace(workspace, () =>
+            Effect.runPromiseExit(wrap(effect)).then((exit) =>
+              resume(Exit.isSuccess(exit) ? Effect.succeed(exit.value) : Effect.failCause(exit.cause)),
+            ),
+          )
+        }),
+      bind:
+        <Args extends readonly unknown[], Result>(fn: (...args: Args) => Result) =>
+        (...args: Args) =>
+          restoreWorkspace(workspace, () => Effect.runSync(wrap(Effect.sync(() => fn(...args))))),
+    } satisfies Shape
+  })
+}
+
+export * as EffectBridge from "./bridge"

package/src/engine/effect/config-service.ts

@@ -1,67 +1,67 @@
-import { Config, Context, Effect, Layer } from "effect"
-
-type ConfigMap = Record<string, Config.Config<unknown>>
-
-/**
- * The service shape inferred from an object of Effect `Config` definitions.
- */
-export type Shape<Fields extends ConfigMap> = {
-  readonly [Key in keyof Fields]: Config.Success<Fields[Key]>
-}
-
-/**
- * A Context service class with generated layers for config-backed services.
- */
-export type ServiceClass<Self, Id extends string, Service> = Context.ServiceClass<Self, Id, Service> & {
-  /** Provide already-parsed config, useful in tests. */
-  readonly layer: (input: Service) => Layer.Layer<Self>
-  /** Parse config once from the active Effect ConfigProvider and provide the service. */
-  readonly defaultLayer: Layer.Layer<Self, Config.ConfigError>
-}
-
-/**
- * Create a Context service whose implementation is derived from Effect `Config`.
- *
- * This keeps Effect `Config` as the source of truth for env names, defaults, and
- * validation while generating a typed service plus convenient production/test
- * layers.
- *
- * ```ts
- * class ServerAuthConfig extends ConfigService.Service<ServerAuthConfig>()(
- *   "@opencode/ServerAuthConfig",
- *   {
- *     password: Config.string("OPENCODE_SERVER_PASSWORD").pipe(Config.option),
- *     username: Config.string("OPENCODE_SERVER_USERNAME").pipe(Config.withDefault("opencode")),
- *   },
- * ) {}
- *
- * const live = ServerAuthConfig.defaultLayer
- * const test = ServerAuthConfig.layer({ password: Option.some("secret"), username: "kit" })
- * ```
- */
-export const Service =
-  <Self>() =>
-  <const Id extends string, const Fields extends ConfigMap>(id: Id, fields: Fields) => {
-    class ConfigTag extends Context.Service<Self, Shape<Fields>>()(id) {
-      static layer(input: Shape<Fields>) {
-        return Layer.succeed(this, this.of(input))
-      }
-
-      static get defaultLayer() {
-        return Layer.effect(
-          this,
-          Config.all(fields)
-            .asEffect()
-            .pipe(
-              // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Config.all preserves the field shape, but its conditional return type also supports iterable inputs.
-              Effect.map((config) => this.of(config as Shape<Fields>)),
-            ),
-        )
-      }
-    }
-
-    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- The generated class carries typed static helpers.
-    return ConfigTag as ServiceClass<Self, Id, Shape<Fields>>
-  }
-
-export * as ConfigService from "./config-service"
+import { Config, Context, Effect, Layer } from "effect"
+
+type ConfigMap = Record<string, Config.Config<unknown>>
+
+/**
+ * The service shape inferred from an object of Effect `Config` definitions.
+ */
+export type Shape<Fields extends ConfigMap> = {
+  readonly [Key in keyof Fields]: Config.Success<Fields[Key]>
+}
+
+/**
+ * A Context service class with generated layers for config-backed services.
+ */
+export type ServiceClass<Self, Id extends string, Service> = Context.ServiceClass<Self, Id, Service> & {
+  /** Provide already-parsed config, useful in tests. */
+  readonly layer: (input: Service) => Layer.Layer<Self>
+  /** Parse config once from the active Effect ConfigProvider and provide the service. */
+  readonly defaultLayer: Layer.Layer<Self, Config.ConfigError>
+}
+
+/**
+ * Create a Context service whose implementation is derived from Effect `Config`.
+ *
+ * This keeps Effect `Config` as the source of truth for env names, defaults, and
+ * validation while generating a typed service plus convenient production/test
+ * layers.
+ *
+ * ```ts
+ * class ServerAuthConfig extends ConfigService.Service<ServerAuthConfig>()(
+ *   "@opencode/ServerAuthConfig",
+ *   {
+ *     password: Config.string("OPENCODE_SERVER_PASSWORD").pipe(Config.option),
+ *     username: Config.string("OPENCODE_SERVER_USERNAME").pipe(Config.withDefault("opencode")),
+ *   },
+ * ) {}
+ *
+ * const live = ServerAuthConfig.defaultLayer
+ * const test = ServerAuthConfig.layer({ password: Option.some("secret"), username: "kit" })
+ * ```
+ */
+export const Service =
+  <Self>() =>
+  <const Id extends string, const Fields extends ConfigMap>(id: Id, fields: Fields) => {
+    class ConfigTag extends Context.Service<Self, Shape<Fields>>()(id) {
+      static layer(input: Shape<Fields>) {
+        return Layer.succeed(this, this.of(input))
+      }
+
+      static get defaultLayer() {
+        return Layer.effect(
+          this,
+          Config.all(fields)
+            .asEffect()
+            .pipe(
+              // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Config.all preserves the field shape, but its conditional return type also supports iterable inputs.
+              Effect.map((config) => this.of(config as Shape<Fields>)),
+            ),
+        )
+      }
+    }
+
+    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- The generated class carries typed static helpers.
+    return ConfigTag as ServiceClass<Self, Id, Shape<Fields>>
+  }
+
+export * as ConfigService from "./config-service"

package/src/engine/effect/instance-ref.ts

@@ -1,11 +1,11 @@
-import { Context } from "effect"
-import type { InstanceContext } from "@/project/instance-context"
-import type { WorkspaceID } from "@/control-plane/schema"
-
-export const InstanceRef = Context.Reference<InstanceContext | undefined>("~opencode/InstanceRef", {
-  defaultValue: () => undefined,
-})
-
-export const WorkspaceRef = Context.Reference<WorkspaceID | undefined>("~opencode/WorkspaceRef", {
-  defaultValue: () => undefined,
-})
+import { Context } from "effect"
+import type { InstanceContext } from "@/project/instance-context"
+import type { WorkspaceID } from "@/control-plane/schema"
+
+export const InstanceRef = Context.Reference<InstanceContext | undefined>("~opencode/InstanceRef", {
+  defaultValue: () => undefined,
+})
+
+export const WorkspaceRef = Context.Reference<WorkspaceID | undefined>("~opencode/WorkspaceRef", {
+  defaultValue: () => undefined,
+})

package/src/engine/effect/instance-registry.ts

@@ -1,12 +1,12 @@
-const disposers = new Set<(directory: string) => Promise<void>>()
-
-export function registerDisposer(disposer: (directory: string) => Promise<void>) {
-  disposers.add(disposer)
-  return () => {
-    disposers.delete(disposer)
-  }
-}
-
-export async function disposeInstance(directory: string) {
-  await Promise.allSettled([...disposers].map((disposer) => disposer(directory)))
-}
+const disposers = new Set<(directory: string) => Promise<void>>()
+
+export function registerDisposer(disposer: (directory: string) => Promise<void>) {
+  disposers.add(disposer)
+  return () => {
+    disposers.delete(disposer)
+  }
+}
+
+export async function disposeInstance(directory: string) {
+  await Promise.allSettled([...disposers].map((disposer) => disposer(directory)))
+}

package/src/engine/effect/instance-state.ts

@@ -1,72 +1,72 @@
-import { Effect, ScopedCache, Scope } from "effect"
-import * as EffectLogger from "@opencode-ai/core/effect/logger"
-import type { InstanceContext } from "@/project/instance-context"
-import { InstanceRef, WorkspaceRef } from "./instance-ref"
-import { registerDisposer } from "./instance-registry"
-import { WorkspaceContext } from "@/control-plane/workspace-context"
-
-const TypeId = "~opencode/InstanceState"
-
-export interface InstanceState<A, E = never, R = never> {
-  readonly [TypeId]: typeof TypeId
-  readonly cache: ScopedCache.ScopedCache<string, A, E, R>
-}
-
-export const context = Effect.gen(function* () {
-  const ctx = yield* InstanceRef
-  if (!ctx) return yield* Effect.die(new Error("InstanceRef not provided"))
-  return ctx
-})
-
-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)
-  })
-
-export * as InstanceState from "./instance-state"
+import { Effect, ScopedCache, Scope } from "effect"
+import * as EffectLogger from "@opencode-ai/core/effect/logger"
+import type { InstanceContext } from "@/project/instance-context"
+import { InstanceRef, WorkspaceRef } from "./instance-ref"
+import { registerDisposer } from "./instance-registry"
+import { WorkspaceContext } from "@/control-plane/workspace-context"
+
+const TypeId = "~opencode/InstanceState"
+
+export interface InstanceState<A, E = never, R = never> {
+  readonly [TypeId]: typeof TypeId
+  readonly cache: ScopedCache.ScopedCache<string, A, E, R>
+}
+
+export const context = Effect.gen(function* () {
+  const ctx = yield* InstanceRef
+  if (!ctx) return yield* Effect.die(new Error("InstanceRef not provided"))
+  return ctx
+})
+
+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)
+  })
+
+export * as InstanceState from "./instance-state"

package/src/engine/effect/promise.ts

@@ -1,17 +1,17 @@
-import { Cause, Effect } from "effect"
-
-export function refineRejection<A, E>(
-  evaluate: (signal: AbortSignal) => PromiseLike<A>,
-  refine: (cause: unknown) => E | undefined,
-) {
-  return Effect.tryPromise(evaluate).pipe(
-    Effect.catch((error) => {
-      const cause = Cause.isUnknownError(error) ? error.cause : error
-      const refined = refine(cause)
-      if (refined !== undefined) return Effect.fail(refined)
-      return Effect.die(cause)
-    }),
-  )
-}
-
-export * as EffectPromise from "./promise"
+import { Cause, Effect } from "effect"
+
+export function refineRejection<A, E>(
+  evaluate: (signal: AbortSignal) => PromiseLike<A>,
+  refine: (cause: unknown) => E | undefined,
+) {
+  return Effect.tryPromise(evaluate).pipe(
+    Effect.catch((error) => {
+      const cause = Cause.isUnknownError(error) ? error.cause : error
+      const refined = refine(cause)
+      if (refined !== undefined) return Effect.fail(refined)
+      return Effect.die(cause)
+    }),
+  )
+}
+
+export * as EffectPromise from "./promise"