@miaws/miaw 1.18.5 → 1.18.6

package/src/config/tui.ts

@@ -1,274 +0,0 @@
-export * as TuiConfig from "./tui"
-
-import path from "path"
-import { mergeDeep, unique } from "remeda"
-import { Cause, Context, Effect, Fiber, Layer } from "effect"
-import { ConfigParse } from "@/config/parse"
-import * as ConfigPaths from "@/config/paths"
-import { migrateTuiConfig } from "./tui-migrate"
-import { resolveHostAttentionSoundPaths } from "./tui-host-attention"
-import { Flag } from "@miaw/core/flag/flag"
-import { isRecord } from "@miaw/tui/util/record"
-import { Global } from "@miaw/core/global"
-import { FSUtil } from "@miaw/core/fs-util"
-import { CurrentWorkingDirectory } from "./tui-cwd"
-import { ConfigPlugin } from "@/config/plugin"
-import { TuiKeybind } from "@miaw/tui/config/keybind"
-import { InstallationLocal, InstallationVersion } from "@miaw/core/installation/version"
-import { makeRuntime } from "@miaw/core/effect/runtime"
-import { Filesystem } from "@/util/filesystem"
-import { ConfigVariable } from "@/config/variable"
-import { Npm } from "@miaw/core/npm"
-import { FormatError, FormatUnknownError } from "@/cli/error"
-import { TuiConfig } from "@miaw/tui/config"
-
-export const Info = TuiConfig.Info
-export type Info = TuiConfig.Info
-
-type Acc = {
-  result: Info
-  plugin_origins: ConfigPlugin.Origin[]
-}
-
-export type Resolved = TuiConfig.Resolved
-
-export type HostMetadata = {
-  plugin_origins?: ConfigPlugin.Origin[]
-}
-
-export interface Interface {
-  readonly get: () => Effect.Effect<Resolved>
-  readonly pluginOrigins: () => Effect.Effect<ConfigPlugin.Origin[]>
-  readonly waitForDependencies: () => Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@miaw/TuiConfig") {}
-
-function pluginScope(file: string, ctx: { directory: string }): ConfigPlugin.Scope {
-  if (Filesystem.contains(ctx.directory, file)) return "local"
-  // if (ctx.worktree !== "/" && Filesystem.contains(ctx.worktree, file)) return "local"
-  return "global"
-}
-
-function normalize(raw: Record<string, unknown>) {
-  const data = { ...raw }
-  if (!("tui" in data)) return data
-  if (!isRecord(data.tui)) {
-    delete data.tui
-    return data
-  }
-
-  const tui = data.tui
-  delete data.tui
-  return {
-    ...tui,
-    ...data,
-  }
-}
-
-function dropUnknownKeybinds(input: Record<string, unknown>) {
-  if (!isRecord(input.keybinds)) return input
-
-  const invalid = TuiKeybind.unknownKeys(input.keybinds)
-  if (!invalid.length) return input
-
-  return {
-    ...input,
-    keybinds: Object.fromEntries(Object.entries(input.keybinds).filter(([key]) => !invalid.includes(key))),
-  }
-}
-
-const loadState = Effect.fn("TuiConfig.loadState")(function* (ctx: { directory: string }) {
-  const afs = yield* FSUtil.Service
-  let appliedOrder = 0
-
-  const resolvePlugins = (config: Info, configFilepath: string): Effect.Effect<Info> =>
-    Effect.gen(function* () {
-      const plugins = config.plugin
-      if (!plugins) return config
-      return {
-        ...config,
-        plugin: yield* Effect.forEach(plugins, (plugin) =>
-          Effect.promise(() => ConfigPlugin.resolvePluginSpec(plugin as ConfigPlugin.Origin["spec"], configFilepath)),
-        ),
-      }
-    })
-
-  const load = (text: string, configFilepath: string): Effect.Effect<Info> =>
-    Effect.gen(function* () {
-      const expanded = yield* Effect.promise(() =>
-        ConfigVariable.substitute({ text, type: "path", path: configFilepath, missing: "empty" }),
-      )
-      const data = ConfigParse.jsonc(expanded, configFilepath)
-      if (!isRecord(data)) return {} as Info
-      // Flatten a nested "tui" key so users who wrote `{ "tui": { ... } }` inside tui.json
-      // (mirroring the old miaw.json shape) still get their settings applied.
-      const normalized = dropUnknownKeybinds(normalize(data))
-      const parsed = ConfigParse.schema(Info, normalized, configFilepath)
-      const validated = parsed.attention?.sounds
-        ? {
-            ...parsed,
-            attention: {
-              ...parsed.attention,
-              sounds: resolveHostAttentionSoundPaths(path.dirname(configFilepath), parsed.attention.sounds),
-            },
-          }
-        : parsed
-      return yield* resolvePlugins(validated, configFilepath)
-    }).pipe(
-      // catchCause (not tapErrorCause + orElseSucceed) because JSONC parsing and validation
-      // can sync-throw — those become defects, which orElseSucceed wouldn't catch.
-      Effect.catchCause((cause) =>
-        Effect.logWarning("skipping invalid tui config", {
-          path: configFilepath,
-          reason: FormatError(Cause.squash(cause)) ?? FormatUnknownError(Cause.squash(cause)),
-        }).pipe(Effect.as({} as Info)),
-      ),
-    )
-
-  const loadFile = (filepath: string): Effect.Effect<Info> =>
-    Effect.gen(function* () {
-      // Silent-swallow non-NotFound read errors (perms, EISDIR, IO) → log + skip.
-      // Matches how parse/schema/plugin failures in load() are handled — every
-      // broken-config path degrades gracefully rather than crashing TUI startup.
-      const text = yield* afs.readFileStringSafe(filepath).pipe(
-        Effect.catchCause((cause) =>
-          Effect.logWarning("failed to read tui config", {
-            path: filepath,
-            reason: FormatError(Cause.squash(cause)) ?? FormatUnknownError(Cause.squash(cause)),
-          }).pipe(Effect.as(undefined)),
-        ),
-      )
-      if (!text) return {} as Info
-      yield* Effect.logInfo("loading tui config", { path: filepath })
-      return yield* load(text, filepath)
-    })
-
-  const mergeFile = (acc: Acc, file: string) =>
-    Effect.gen(function* () {
-      const data = yield* loadFile(file)
-      if (Object.keys(data).length) {
-        appliedOrder += 1
-        yield* Effect.logInfo("applying tui config", { path: file, order: appliedOrder })
-      }
-      acc.result = mergeDeep(acc.result, data)
-      if (!data.plugin?.length) return
-
-      const scope = pluginScope(file, ctx)
-      const plugins = ConfigPlugin.deduplicatePluginOrigins([
-        ...acc.plugin_origins,
-        ...data.plugin.map((spec) => ({ spec: spec as ConfigPlugin.Origin["spec"], scope, source: file })),
-      ])
-      acc.result = {
-        ...acc.result,
-        plugin: plugins.map((item) => item.spec),
-      }
-      acc.plugin_origins = plugins
-    })
-
-  // Every config dir we may read from: global config dir, any `.miaw`
-  // folders between cwd and home, and MIAW_CONFIG_DIR.
-  const directories = yield* ConfigPaths.directories(ctx.directory)
-  yield* Effect.promise(() => migrateTuiConfig({ directories, cwd: ctx.directory }))
-
-  const projectFiles = Flag.MIAW_DISABLE_PROJECT_CONFIG ? [] : yield* ConfigPaths.files("tui", ctx.directory)
-
-  const acc: Acc = {
-    result: {},
-    plugin_origins: [],
-  }
-
-  // 1. Global tui config (lowest precedence).
-  for (const file of ConfigPaths.fileInDirectory(Global.Path.config, "tui")) {
-    yield* mergeFile(acc, file)
-  }
-
-  // 2. Explicit MIAW_TUI_CONFIG override, if set.
-  if (Flag.MIAW_TUI_CONFIG) {
-    const configFile = Flag.MIAW_TUI_CONFIG
-    yield* mergeFile(acc, configFile)
-    yield* Effect.logDebug("loaded custom tui config", { path: configFile })
-  }
-
-  // 3. Project tui files, applied root-first so the closest file wins.
-  for (const file of projectFiles) {
-    yield* mergeFile(acc, file)
-  }
-
-  // 4. `.miaw` directories (and MIAW_CONFIG_DIR) discovered while
-  // walking up the tree. Also returned below so callers can install plugin
-  // dependencies from each location.
-  const dirs = unique(directories).filter((dir) => dir.endsWith(".miaw") || dir === Flag.MIAW_CONFIG_DIR)
-
-  for (const dir of dirs) {
-    if (!dir.endsWith(".miaw") && dir !== Flag.MIAW_CONFIG_DIR) continue
-    for (const file of ConfigPaths.fileInDirectory(dir, "tui")) {
-      yield* mergeFile(acc, file)
-    }
-  }
-
-  const result = TuiConfig.resolve(
-    {
-      ...acc.result,
-    },
-    {
-      terminalSuspend: process.platform !== "win32",
-    },
-  )
-
-  return {
-    config: result,
-    pluginOrigins: acc.plugin_origins,
-    dirs: result.plugin?.length ? dirs : [],
-  }
-})
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const directory = yield* CurrentWorkingDirectory
-    const npm = yield* Npm.Service
-    const data = yield* loadState({ directory })
-    const deps = yield* Effect.forEach(
-      data.dirs,
-      (dir) =>
-        npm
-          .install(dir, {
-            add: [
-              {
-                name: "@miaw/plugin",
-                version: InstallationLocal ? undefined : InstallationVersion,
-              },
-            ],
-          })
-          .pipe(Effect.forkScoped),
-      {
-        concurrency: "unbounded",
-      },
-    )
-
-    const get = Effect.fn("TuiConfig.get")(() => Effect.succeed(data.config))
-    const pluginOrigins = Effect.fn("TuiConfig.pluginOrigins")(() => Effect.succeed(data.pluginOrigins))
-
-    const waitForDependencies = Effect.fn("TuiConfig.waitForDependencies")(() =>
-      Effect.forEach(deps, Fiber.join, { concurrency: "unbounded" }).pipe(Effect.ignore(), Effect.asVoid),
-    )
-    return Service.of({ get, pluginOrigins, waitForDependencies })
-  }).pipe(Effect.withSpan("TuiConfig.layer")),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(Npm.defaultLayer), Layer.provide(FSUtil.defaultLayer))
-
-const { runPromise } = makeRuntime(Service, defaultLayer)
-
-export async function waitForDependencies() {
-  await runPromise((svc) => svc.waitForDependencies())
-}
-
-export async function get() {
-  return runPromise((svc) => svc.get())
-}
-
-export async function pluginOrigins() {
-  return runPromise((svc) => svc.pluginOrigins())
-}

package/src/config/variable.ts

@@ -1,91 +0,0 @@
-export * as ConfigVariable from "./variable"
-
-import path from "path"
-import os from "os"
-import { Filesystem } from "@/util/filesystem"
-import { InvalidError } from "@miaw/core/v1/config/error"
-
-type ParseSource =
-  | {
-      type: "path"
-      path: string
-    }
-  | {
-      type: "virtual"
-      source: string
-      dir: string
-    }
-
-type SubstituteInput = ParseSource & {
-  text: string
-  missing?: "error" | "empty"
-  env?: Record<string, string>
-}
-
-function source(input: ParseSource) {
-  return input.type === "path" ? input.path : input.source
-}
-
-function dir(input: ParseSource) {
-  return input.type === "path" ? path.dirname(input.path) : input.dir
-}
-
-/** Apply {env:VAR} and {file:path} substitutions to config text. */
-export async function substitute(input: SubstituteInput) {
-  const missing = input.missing ?? "error"
-  let text = input.text.replace(/\{env:([^}]+)\}/g, (_, varName) => {
-    return (input.env?.[varName] ?? process.env[varName]) || ""
-  })
-
-  const fileMatches = Array.from(text.matchAll(/\{file:[^}]+\}/g))
-  if (!fileMatches.length) return text
-
-  const configDir = dir(input)
-  const configSource = source(input)
-  let out = ""
-  let cursor = 0
-
-  for (const match of fileMatches) {
-    const token = match[0]
-    const index = match.index
-    out += text.slice(cursor, index)
-
-    const lineStart = text.lastIndexOf("\n", index - 1) + 1
-    const prefix = text.slice(lineStart, index).trimStart()
-    if (prefix.startsWith("//")) {
-      out += token
-      cursor = index + token.length
-      continue
-    }
-
-    let filePath = token.replace(/^\{file:/, "").replace(/\}$/, "")
-    if (filePath.startsWith("~/")) {
-      filePath = path.join(os.homedir(), filePath.slice(2))
-    }
-
-    const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(configDir, filePath)
-    const fileContent = (
-      await Filesystem.readText(resolvedPath).catch((error: NodeJS.ErrnoException) => {
-        if (missing === "empty") return ""
-
-        const errMsg = `bad file reference: "${token}"`
-        if (error.code === "ENOENT") {
-          throw new InvalidError(
-            {
-              path: configSource,
-              message: errMsg + ` ${resolvedPath} does not exist`,
-            },
-            { cause: error },
-          )
-        }
-        throw new InvalidError({ path: configSource, message: errMsg }, { cause: error })
-      })
-    ).trim()
-
-    out += JSON.stringify(fileContent).slice(1, -1)
-    cursor = index + token.length
-  }
-
-  out += text.slice(cursor)
-  return out
-}

package/src/control-plane/adapters/index.ts

@@ -1,41 +0,0 @@
-import type { ProjectV2 } from "@miaw/core/project"
-import type { WorkspaceAdapter, WorkspaceAdapterEntry } from "../types"
-import { WorktreeAdapter } from "./worktree"
-
-const BUILTIN: Record<string, WorkspaceAdapter> = {
-  worktree: WorktreeAdapter,
-}
-
-const state = new Map<ProjectV2.ID, Map<string, WorkspaceAdapter>>()
-
-export function getAdapter(projectID: ProjectV2.ID, type: string): WorkspaceAdapter {
-  const custom = state.get(projectID)?.get(type)
-  if (custom) return custom
-
-  const builtin = BUILTIN[type]
-  if (builtin) return builtin
-
-  throw new Error(`Unknown workspace adapter: ${type}`)
-}
-
-export function listAdapters(projectID: ProjectV2.ID): WorkspaceAdapterEntry[] {
-  return registeredAdapters(projectID).map(([type, adapter]) => ({
-    type,
-    name: adapter.name,
-    description: adapter.description,
-  }))
-}
-
-export function registeredAdapters(projectID: ProjectV2.ID): [string, WorkspaceAdapter][] {
-  const adapters = new Map(Object.entries(BUILTIN))
-  for (const [type, adapter] of state.get(projectID)?.entries() ?? []) adapters.set(type, adapter)
-  return [...adapters.entries()]
-}
-
-// Plugins can be loaded per-project so we need to scope them. If you
-// want to install a global one pass `ProjectV2.ID.global`
-export function registerAdapter(projectID: ProjectV2.ID, type: string, adapter: WorkspaceAdapter) {
-  const adapters = state.get(projectID) ?? new Map<string, WorkspaceAdapter>()
-  adapters.set(type, adapter)
-  state.set(projectID, adapters)
-}

package/src/control-plane/adapters/worktree.ts

@@ -1,96 +0,0 @@
-import { Effect, Schema } from "effect"
-import { InstanceRef, WorkspaceRef } from "@/effect/instance-ref"
-import { type WorkspaceAdapter, type WorkspaceAdapterContext, WorkspaceInfo } from "../types"
-
-const WorktreeConfig = Schema.Struct({
-  name: WorkspaceInfo.fields.name,
-  branch: Schema.optional(Schema.NullOr(Schema.String)),
-  directory: Schema.String,
-})
-const decodeWorktreeConfig = Schema.decodeUnknownSync(WorktreeConfig)
-
-async function loadWorktree() {
-  const [{ AppRuntime }, { Worktree }] = await Promise.all([import("@/effect/app-runtime"), import("@/worktree")])
-  return { AppRuntime, Worktree }
-}
-
-function requireInstance(context: WorkspaceAdapterContext | undefined) {
-  if (!context?.instance) throw new Error("Worktree adapter requires an instance context")
-  return context.instance
-}
-
-const provideContext = <A, E, R>(effect: Effect.Effect<A, E, R>, context: WorkspaceAdapterContext | undefined) =>
-  effect.pipe(
-    Effect.provideService(InstanceRef, requireInstance(context)),
-    Effect.provideService(WorkspaceRef, context?.workspaceID),
-  )
-
-export const WorktreeAdapter: WorkspaceAdapter = {
-  name: "Worktree",
-  description: "Create a git worktree",
-  async configure(info, context) {
-    const { AppRuntime, Worktree } = await loadWorktree()
-    const next = await AppRuntime.runPromise(
-      provideContext(
-        Worktree.Service.use((svc) => svc.makeWorktreeInfo({ detached: true })),
-        context,
-      ),
-    )
-    return {
-      ...info,
-      name: next.name,
-      directory: next.directory,
-    }
-  },
-  async create(info, _env, _from, context) {
-    const { AppRuntime, Worktree } = await loadWorktree()
-    const config = decodeWorktreeConfig(info)
-    await AppRuntime.runPromise(
-      provideContext(
-        Worktree.Service.use((svc) =>
-          svc.createFromInfo({
-            name: config.name,
-            directory: config.directory,
-            ...(config.branch ? { branch: config.branch } : {}),
-          }),
-        ),
-        context,
-      ),
-    )
-  },
-  async list(context) {
-    const { AppRuntime, Worktree } = await loadWorktree()
-    const ctx = requireInstance(context)
-    return (
-      await AppRuntime.runPromise(
-        provideContext(
-          Worktree.Service.use((svc) => svc.list()),
-          context,
-        ),
-      )
-    ).map((info) => ({
-      type: "worktree",
-      name: info.name,
-      branch: info.branch,
-      directory: info.directory,
-      projectID: ctx.project.id,
-    }))
-  },
-  async remove(info, context) {
-    const { AppRuntime, Worktree } = await loadWorktree()
-    const config = decodeWorktreeConfig(info)
-    await AppRuntime.runPromise(
-      provideContext(
-        Worktree.Service.use((svc) => svc.remove({ directory: config.directory })),
-        context,
-      ),
-    )
-  },
-  target(info) {
-    const config = decodeWorktreeConfig(info)
-    return {
-      type: "local",
-      directory: config.directory,
-    }
-  },
-}

package/src/control-plane/dev/README.md

@@ -1,19 +0,0 @@
-This is a plugin to simulate a remote environment locally. Add this to `.miaw/miaw.jsonc`:
-
-```json
-  "plugin": ["../packages/miaw/src/control-plane/dev/debug-workspace-plugin.ts"],
-```
-
-In a separate terminal, run a separate Miaw server. This will act like a remote server and the local instance will proxy all requests to it:
-
-```
-./packages/miaw/script/run-workspace-server
-```
-
-With the plugin install, you can now run Miaw and create a `debug` workspace type. This will create a "remote" workspace which talks to the second workspace server started above.
-
-How this works:
-
-- The workspace server needs to know the workspace id and port to run. It waits for this information to be written to a file and starts the server when the data is written.
-- The debug plugin writes this information in the `create` call to the workspace. So create a `debug` workspace will always kick off a new external server.
-- The server script watches for file changes, so whenver you create a new `debug` workspace it will restart with the new information. This means that there is only ever one working `debug` workspace at a time; when you create a new one all previous sessions will show that it can't connect because previous debug workspaces do not exist.

package/src/control-plane/dev/debug-workspace-plugin.ts

@@ -1,73 +0,0 @@
-import type { Plugin } from "@miaw/plugin"
-import { rename, writeFile } from "node:fs/promises"
-import { randomInt } from "node:crypto"
-import { setTimeout as sleep } from "node:timers/promises"
-
-const DEV_DATA_FILE = "/tmp/miaw-workspace-dev-data.json"
-const DEV_DATA_TEMP_FILE = `${DEV_DATA_FILE}.tmp`
-
-async function waitForHealth(port: number) {
-  const url = `http://127.0.0.1:${port}/global/health`
-  const started = Date.now()
-
-  while (Date.now() - started < 30_000) {
-    try {
-      const response = await fetch(url)
-      if (response.ok) {
-        return
-      }
-    } catch {}
-
-    await sleep(250)
-  }
-
-  throw new Error(`Timed out waiting for debug server health check at ${url}`)
-}
-
-let PORT: number | undefined
-
-async function writeDebugData(port: number, id: string, env: Record<string, string | undefined>) {
-  await writeFile(
-    DEV_DATA_TEMP_FILE,
-    JSON.stringify(
-      {
-        port,
-        id,
-        env,
-      },
-      null,
-      2,
-    ),
-  )
-
-  await rename(DEV_DATA_TEMP_FILE, DEV_DATA_FILE)
-}
-
-export const DebugWorkspacePlugin: Plugin = async ({ experimental_workspace }) => {
-  experimental_workspace.register("debug", {
-    name: "Debug",
-    description: "Create a debugging server",
-    configure(config) {
-      return config
-    },
-    async create(config, env) {
-      const port = randomInt(5000, 9001)
-      PORT = port
-
-      await writeDebugData(port, config.id, env)
-
-      await waitForHealth(port)
-    },
-    async remove(_config) {},
-    target(_config) {
-      return {
-        type: "remote",
-        url: `http://localhost:${PORT!}/`,
-      }
-    },
-  })
-
-  return {}
-}
-
-export default DebugWorkspacePlugin

package/src/control-plane/types.ts

@@ -1,59 +0,0 @@
-import { Schema, Struct } from "effect"
-import { ProjectV2 } from "@miaw/core/project"
-import type { InstanceContext } from "@/project/instance-context"
-import { WorkspaceV2 } from "@miaw/core/workspace"
-import type { DeepMutable } from "@miaw/core/schema"
-
-export const WorkspaceInfo = Schema.Struct({
-  id: WorkspaceV2.ID,
-  type: Schema.String,
-  name: Schema.String,
-  branch: Schema.optional(Schema.NullOr(Schema.String)),
-  directory: Schema.optional(Schema.NullOr(Schema.String)),
-  extra: Schema.optional(Schema.NullOr(Schema.Unknown)),
-  projectID: ProjectV2.ID,
-}).annotate({ identifier: "Workspace" })
-export type WorkspaceInfo = DeepMutable<Schema.Schema.Type<typeof WorkspaceInfo>>
-
-export const WorkspaceListedInfo = Schema.Struct(Struct.omit(WorkspaceInfo.fields, ["id"])).annotate({
-  identifier: "WorkspaceListedInfo",
-})
-export type WorkspaceListedInfo = DeepMutable<Schema.Schema.Type<typeof WorkspaceListedInfo>>
-
-export const WorkspaceAdapterEntry = Schema.Struct({
-  type: Schema.String,
-  name: Schema.String,
-  description: Schema.String,
-})
-export type WorkspaceAdapterEntry = Schema.Schema.Type<typeof WorkspaceAdapterEntry>
-
-export type Target =
-  | {
-      type: "local"
-      directory: string
-    }
-  | {
-      type: "remote"
-      url: string | URL
-      headers?: HeadersInit
-    }
-
-export type WorkspaceAdapterContext = {
-  readonly instance?: InstanceContext
-  readonly workspaceID?: WorkspaceV2.ID
-}
-
-export type WorkspaceAdapter = {
-  name: string
-  description: string
-  configure(info: WorkspaceInfo, context?: WorkspaceAdapterContext): WorkspaceInfo | Promise<WorkspaceInfo>
-  create(
-    info: WorkspaceInfo,
-    env: Record<string, string | undefined>,
-    from?: WorkspaceInfo,
-    context?: WorkspaceAdapterContext,
-  ): Promise<void>
-  list?(context?: WorkspaceAdapterContext): WorkspaceListedInfo[] | Promise<WorkspaceListedInfo[]>
-  remove(info: WorkspaceInfo, context?: WorkspaceAdapterContext): Promise<void>
-  target(info: WorkspaceInfo, context?: WorkspaceAdapterContext): Target | Promise<Target>
-}

package/src/control-plane/util.ts

@@ -1,39 +0,0 @@
-import { GlobalBus, type GlobalEvent } from "@/bus/global"
-import { Effect } from "effect"
-
-export function waitEvent(input: { timeout: number; signal?: AbortSignal; fn: (event: GlobalEvent) => boolean }) {
-  if (input.signal?.aborted) return Effect.fail(input.signal.reason ?? new Error("Request aborted"))
-
-  return Effect.callback<void, unknown>((resume) => {
-    const abort = () => {
-      cleanup()
-      resume(Effect.fail(input.signal?.reason ?? new Error("Request aborted")))
-    }
-
-    const handler = (event: GlobalEvent) => {
-      try {
-        if (!input.fn(event)) return
-        cleanup()
-        resume(Effect.void)
-      } catch (error) {
-        cleanup()
-        resume(Effect.fail(error))
-      }
-    }
-
-    const cleanup = () => {
-      clearTimeout(timeout)
-      GlobalBus.off("event", handler)
-      input.signal?.removeEventListener("abort", abort)
-    }
-
-    const timeout = setTimeout(() => {
-      cleanup()
-      resume(Effect.fail(new Error("Timed out waiting for global event")))
-    }, input.timeout)
-
-    GlobalBus.on("event", handler)
-    input.signal?.addEventListener("abort", abort, { once: true })
-    return Effect.sync(cleanup)
-  })
-}