soraacode 0.2.0 → 0.2.1

package/src/plugin/shared.ts

@@ -1,323 +0,0 @@
-import path from "path"
-import { fileURLToPath, pathToFileURL } from "url"
-import npa from "npm-package-arg"
-import semver from "semver"
-import { Filesystem } from "@/util/filesystem"
-import { isRecord } from "@/util/record"
-import { Npm } from "@soraacode/core/npm"
-
-// Old npm package names for plugins that are now built-in
-export const DEPRECATED_PLUGIN_PACKAGES = ["opencode-openai-codex-auth", "opencode-copilot-auth"]
-
-export function isDeprecatedPlugin(spec: string) {
-  return DEPRECATED_PLUGIN_PACKAGES.some((pkg) => spec.includes(pkg))
-}
-
-function parse(spec: string) {
-  try {
-    return npa(spec)
-  } catch {}
-}
-
-export function parsePluginSpecifier(spec: string) {
-  const hit = parse(spec)
-  if (hit?.type === "alias" && !hit.name) {
-    const sub = (hit as npa.AliasResult).subSpec
-    if (sub?.name) {
-      const version = !sub.rawSpec || sub.rawSpec === "*" ? "latest" : sub.rawSpec
-      return { pkg: sub.name, version }
-    }
-  }
-  if (!hit?.name) return { pkg: spec, version: "" }
-  if (hit.raw === hit.name) return { pkg: hit.name, version: "latest" }
-  return { pkg: hit.name, version: hit.rawSpec }
-}
-
-export type PluginSource = "file" | "npm"
-export type PluginKind = "server" | "tui"
-type PluginMode = "strict" | "detect"
-
-export type PluginPackage = {
-  dir: string
-  pkg: string
-  json: Record<string, unknown>
-}
-
-export type PluginEntry = {
-  spec: string
-  source: PluginSource
-  target: string
-  pkg?: PluginPackage
-  entry?: string
-}
-
-const INDEX_FILES = ["index.ts", "index.tsx", "index.js", "index.mjs", "index.cjs"]
-
-export function pluginSource(spec: string): PluginSource {
-  if (isPathPluginSpec(spec)) return "file"
-  return "npm"
-}
-
-function resolveExportPath(raw: string, dir: string) {
-  if (raw.startsWith("file://")) return fileURLToPath(raw)
-  if (path.isAbsolute(raw)) return raw
-  return path.resolve(dir, raw)
-}
-
-function isAbsolutePath(raw: string) {
-  return path.isAbsolute(raw) || /^[A-Za-z]:[\\/]/.test(raw)
-}
-
-function extractExportValue(value: unknown): string | undefined {
-  if (typeof value === "string") return value
-  if (!isRecord(value)) return undefined
-  for (const key of ["import", "default"]) {
-    const nested = value[key]
-    if (typeof nested === "string") return nested
-  }
-  return undefined
-}
-
-function packageMain(pkg: PluginPackage) {
-  const value = pkg.json.main
-  if (typeof value !== "string") return
-  const next = value.trim()
-  if (!next) return
-  return next
-}
-
-function resolvePackageFile(spec: string, raw: string, kind: string, pkg: PluginPackage) {
-  const resolved = resolveExportPath(raw, pkg.dir)
-  const root = Filesystem.resolve(pkg.dir)
-  const next = Filesystem.resolve(resolved)
-  if (!Filesystem.contains(root, next)) {
-    throw new Error(`Plugin ${spec} resolved ${kind} entry outside plugin directory`)
-  }
-  return next
-}
-
-function resolvePackagePath(spec: string, raw: string, kind: PluginKind, pkg: PluginPackage) {
-  return pathToFileURL(resolvePackageFile(spec, raw, kind, pkg)).href
-}
-
-function resolvePackageEntrypoint(spec: string, kind: PluginKind, pkg: PluginPackage) {
-  const exports = pkg.json.exports
-  if (isRecord(exports)) {
-    const raw = extractExportValue(exports[`./${kind}`])
-    if (raw) return resolvePackagePath(spec, raw, kind, pkg)
-  }
-
-  if (kind !== "server") return
-  const main = packageMain(pkg)
-  if (!main) return
-  return resolvePackagePath(spec, main, kind, pkg)
-}
-
-function targetPath(target: string) {
-  if (target.startsWith("file://")) return fileURLToPath(target)
-  if (path.isAbsolute(target)) return target
-}
-
-async function resolveDirectoryIndex(dir: string) {
-  for (const name of INDEX_FILES) {
-    const file = path.join(dir, name)
-    if (await Filesystem.exists(file)) return file
-  }
-}
-
-async function resolveTargetDirectory(target: string) {
-  const file = targetPath(target)
-  if (!file) return
-  const stat = await Filesystem.statAsync(file)
-  if (!stat?.isDirectory()) return
-  return file
-}
-
-async function resolvePluginEntrypoint(spec: string, target: string, kind: PluginKind, pkg?: PluginPackage) {
-  const source = pluginSource(spec)
-  const hit =
-    pkg ?? (source === "npm" ? await readPluginPackage(target) : await readPluginPackage(target).catch(() => undefined))
-  if (!hit) return target
-
-  const entry = resolvePackageEntrypoint(spec, kind, hit)
-  if (entry) return entry
-
-  const dir = await resolveTargetDirectory(target)
-
-  if (kind === "tui") {
-    if (source === "file" && dir) {
-      const index = await resolveDirectoryIndex(dir)
-      if (index) return pathToFileURL(index).href
-    }
-
-    if (source === "npm") return
-    if (dir) return
-
-    return target
-  }
-
-  if (dir && isRecord(hit.json.exports)) {
-    if (source === "file") {
-      const index = await resolveDirectoryIndex(dir)
-      if (index) return pathToFileURL(index).href
-    }
-
-    return
-  }
-
-  return target
-}
-
-export function isPathPluginSpec(spec: string) {
-  return spec.startsWith("file://") || spec.startsWith(".") || isAbsolutePath(spec)
-}
-
-export async function resolvePathPluginTarget(spec: string) {
-  const raw = spec.startsWith("file://") ? fileURLToPath(spec) : spec
-  const file = path.isAbsolute(raw) || /^[A-Za-z]:[\\/]/.test(raw) ? raw : path.resolve(raw)
-  const stat = await Filesystem.statAsync(file)
-  if (!stat?.isDirectory()) {
-    if (spec.startsWith("file://")) return spec
-    return pathToFileURL(file).href
-  }
-
-  if (await Filesystem.exists(path.join(file, "package.json"))) {
-    return pathToFileURL(file).href
-  }
-
-  const index = await resolveDirectoryIndex(file)
-  if (index) return pathToFileURL(index).href
-
-  throw new Error(`Plugin directory ${file} is missing package.json or index file`)
-}
-
-export async function checkPluginCompatibility(target: string, opencodeVersion: string, pkg?: PluginPackage) {
-  if (!semver.valid(opencodeVersion) || semver.major(opencodeVersion) === 0) return
-  const hit = pkg ?? (await readPluginPackage(target).catch(() => undefined))
-  if (!hit) return
-  const engines = hit.json.engines
-  if (!isRecord(engines)) return
-  const range = engines.opencode
-  if (typeof range !== "string") return
-  if (!semver.satisfies(opencodeVersion, range)) {
-    throw new Error(`Plugin requires opencode ${range} but running ${opencodeVersion}`)
-  }
-}
-
-export async function resolvePluginTarget(spec: string) {
-  if (isPathPluginSpec(spec)) return resolvePathPluginTarget(spec)
-  const hit = parse(spec)
-  const pkg = hit?.name && hit.raw === hit.name ? `${hit.name}@latest` : spec
-  const result = await Npm.add(pkg)
-  return result.directory
-}
-
-export async function readPluginPackage(target: string): Promise<PluginPackage> {
-  const file = target.startsWith("file://") ? fileURLToPath(target) : target
-  const stat = await Filesystem.statAsync(file)
-  const dir = stat?.isDirectory() ? file : path.dirname(file)
-  const pkg = path.join(dir, "package.json")
-  const json = await Filesystem.readJson<Record<string, unknown>>(pkg)
-  return { dir, pkg, json }
-}
-
-export async function createPluginEntry(spec: string, target: string, kind: PluginKind): Promise<PluginEntry> {
-  const source = pluginSource(spec)
-  const pkg =
-    source === "npm" ? await readPluginPackage(target) : await readPluginPackage(target).catch(() => undefined)
-  const entry = await resolvePluginEntrypoint(spec, target, kind, pkg)
-  return {
-    spec,
-    source,
-    target,
-    pkg,
-    entry,
-  }
-}
-
-export function readPackageThemes(spec: string, pkg: PluginPackage) {
-  const field = pkg.json["oc-themes"]
-  if (field === undefined) return []
-  if (!Array.isArray(field)) {
-    throw new TypeError(`Plugin ${spec} has invalid oc-themes field`)
-  }
-
-  const list = field.map((item) => {
-    if (typeof item !== "string") {
-      throw new TypeError(`Plugin ${spec} has invalid oc-themes entry`)
-    }
-
-    const raw = item.trim()
-    if (!raw) {
-      throw new TypeError(`Plugin ${spec} has empty oc-themes entry`)
-    }
-    if (raw.startsWith("file://") || isAbsolutePath(raw)) {
-      throw new TypeError(`Plugin ${spec} oc-themes entry must be relative: ${item}`)
-    }
-
-    return resolvePackageFile(spec, raw, "oc-themes", pkg)
-  })
-
-  return Array.from(new Set(list))
-}
-
-export function readPluginId(id: unknown, spec: string) {
-  if (id === undefined) return
-  if (typeof id !== "string") throw new TypeError(`Plugin ${spec} has invalid id type ${typeof id}`)
-  const value = id.trim()
-  if (!value) throw new TypeError(`Plugin ${spec} has an empty id`)
-  return value
-}
-
-export function readV1Plugin(
-  mod: Record<string, unknown>,
-  spec: string,
-  kind: PluginKind,
-  mode: PluginMode = "strict",
-) {
-  const value = mod.default
-  if (!isRecord(value)) {
-    if (mode === "detect") return
-    throw new TypeError(`Plugin ${spec} must default export an object with ${kind}()`)
-  }
-  if (mode === "detect" && !("id" in value) && !("server" in value) && !("tui" in value)) return
-
-  const server = "server" in value ? value.server : undefined
-  const tui = "tui" in value ? value.tui : undefined
-  if (server !== undefined && typeof server !== "function") {
-    throw new TypeError(`Plugin ${spec} has invalid server export`)
-  }
-  if (tui !== undefined && typeof tui !== "function") {
-    throw new TypeError(`Plugin ${spec} has invalid tui export`)
-  }
-  if (server !== undefined && tui !== undefined) {
-    throw new TypeError(`Plugin ${spec} must default export either server() or tui(), not both`)
-  }
-  if (kind === "server" && server === undefined) {
-    throw new TypeError(`Plugin ${spec} must default export an object with server()`)
-  }
-  if (kind === "tui" && tui === undefined) {
-    throw new TypeError(`Plugin ${spec} must default export an object with tui()`)
-  }
-
-  return value
-}
-
-export async function resolvePluginId(
-  source: PluginSource,
-  spec: string,
-  target: string,
-  id: string | undefined,
-  pkg?: PluginPackage,
-) {
-  if (source === "file") {
-    if (id) return id
-    throw new TypeError(`Path plugin ${spec} must export id`)
-  }
-  if (id) return id
-  const hit = pkg ?? (await readPluginPackage(target))
-  if (typeof hit.json.name !== "string" || !hit.json.name.trim()) {
-    throw new TypeError(`Plugin package ${hit.pkg} is missing name`)
-  }
-  return hit.json.name.trim()
-}

package/src/project/bootstrap-service.ts

@@ -1,9 +0,0 @@
-import { Context, Effect } from "effect"
-
-export interface Interface {
-  readonly run: Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/InstanceBootstrap") {}
-
-export * as InstanceBootstrap from "./bootstrap-service"

package/src/project/bootstrap.ts

@@ -1,58 +0,0 @@
-import { makeGlobalNode } from "@soraacode/core/effect/app-node"
-import { Plugin } from "../plugin"
-import { Format } from "../format"
-import { LSP } from "@/lsp/lsp"
-import { Snapshot } from "../snapshot"
-import * as Project from "./project"
-import * as Vcs from "./vcs"
-import { InstanceState } from "@/effect/instance-state"
-import { ShareNext } from "@/share/share-next"
-import { Effect, Layer } from "effect"
-import { Config } from "@/config/config"
-import { Service } from "./bootstrap-service"
-
-export { Service } from "./bootstrap-service"
-export type { Interface } from "./bootstrap-service"
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    // Yield each bootstrap dep at layer init so `run` itself has R = never.
-    // InstanceStore imports only the lightweight tag from bootstrap-service.ts,
-    // so it can depend on bootstrap without importing this implementation graph.
-    const config = yield* Config.Service
-    const format = yield* Format.Service
-    const lsp = yield* LSP.Service
-    const plugin = yield* Plugin.Service
-    const project = yield* Project.Service
-    const shareNext = yield* ShareNext.Service
-    const snapshot = yield* Snapshot.Service
-    const vcs = yield* Vcs.Service
-
-    const run = Effect.gen(function* () {
-      const ctx = yield* InstanceState.context
-      yield* Effect.logInfo("bootstrapping", { directory: ctx.directory })
-      // everything depends on config so eager load it for nice traces
-      yield* config.get()
-      // Plugin can mutate config so it has to be initialized before anything else.
-      yield* plugin.init()
-      // Each service self-manages its own slow work via Effect.forkScoped against
-      // its per-instance state scope. We just await materialization here.
-      yield* Effect.forEach(
-        [lsp, shareNext, format, vcs, snapshot, project],
-        (s) => s.init().pipe(Effect.catchCause((cause) => Effect.logWarning("init failed", { cause }))),
-        { concurrency: "unbounded", discard: true },
-      ).pipe(Effect.withSpan("InstanceBootstrap.init"))
-    }).pipe(Effect.withSpan("InstanceBootstrap"))
-
-    return Service.of({ run })
-  }),
-)
-
-export const node = makeGlobalNode({
-  service: Service,
-  layer: layer,
-  deps: [Config.node, Format.node, LSP.node, Plugin.node, Project.node, ShareNext.node, Snapshot.node, Vcs.node],
-})
-
-export * as InstanceBootstrap from "./bootstrap"

package/src/project/instance-context.ts

@@ -1,24 +0,0 @@
-import { LocalContext } from "@/util/local-context"
-import { FSUtil } from "@soraacode/core/fs-util"
-import type * as Project from "./project"
-
-export interface InstanceContext {
-  directory: string
-  worktree: string
-  project: Project.Info
-}
-
-export const context = LocalContext.create<InstanceContext>("instance")
-
-/**
- * Check if a path is within the project boundary.
- * Returns true if path is inside ctx.directory OR ctx.worktree.
- * Paths within the worktree but outside the working directory should not trigger external_directory permission.
- */
-export function containsPath(filepath: string, ctx: InstanceContext): boolean {
-  if (FSUtil.contains(ctx.directory, filepath)) return true
-  // Non-git projects set worktree to "/" which would match ANY absolute path.
-  // Skip worktree check in this case to preserve external_directory permissions.
-  if (ctx.worktree === "/") return false
-  return FSUtil.contains(ctx.worktree, filepath)
-}

package/src/project/instance-runtime.ts

@@ -1,16 +0,0 @@
-import { AppRuntime } from "@/effect/app-runtime"
-import { type InstanceContext } from "./instance-context"
-import { InstanceStore, type LoadInput } from "./instance-store"
-
-// Bridge for Promise/ALS callers that cannot yet yield InstanceStore.Service.
-// Delete this module once those callers are migrated to Effect boundaries that
-// provide InstanceStore directly.
-
-export const load = (input: LoadInput) => AppRuntime.runPromise(InstanceStore.Service.use((store) => store.load(input)))
-export const disposeInstance = (ctx: InstanceContext) =>
-  AppRuntime.runPromise(InstanceStore.Service.use((store) => store.dispose(ctx)))
-export const disposeAllInstances = () => AppRuntime.runPromise(InstanceStore.Service.use((store) => store.disposeAll()))
-export const reloadInstance = (input: LoadInput) =>
-  AppRuntime.runPromise(InstanceStore.Service.use((store) => store.reload(input)))
-
-export * as InstanceRuntime from "./instance-runtime"

package/src/project/instance-store.ts

@@ -1,213 +0,0 @@
-import { LayerNode } from "@soraacode/core/effect/layer-node"
-import { makeGlobalNode, Node } from "@soraacode/core/effect/app-node"
-import { GlobalBus } from "@/bus/global"
-import { serviceUse } from "@soraacode/core/effect/service-use"
-import { WorkspaceContext } from "@/control-plane/workspace-context"
-import { InstanceRef } from "@/effect/instance-ref"
-import { disposeInstance as runDisposers } from "@/effect/instance-registry"
-import { FSUtil } from "@soraacode/core/fs-util"
-import { Context, Deferred, Duration, Effect, Exit, Layer, Scope } from "effect"
-import { type InstanceContext } from "./instance-context"
-import { InstanceBootstrap } from "./bootstrap-service"
-import * as Project from "./project"
-
-export interface LoadInput {
-  directory: string
-  worktree?: string
-  project?: Project.Info
-}
-
-export interface Interface {
-  readonly load: (input: LoadInput) => Effect.Effect<InstanceContext>
-  readonly reload: (input: LoadInput) => Effect.Effect<InstanceContext>
-  readonly dispose: (ctx: InstanceContext) => Effect.Effect<void>
-  readonly disposeDirectory: (directory: string) => Effect.Effect<void>
-  readonly disposeAll: () => Effect.Effect<void>
-  readonly provide: <A, E, R>(input: LoadInput, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/InstanceStore") {}
-
-export const use = serviceUse(Service)
-
-interface Entry {
-  readonly deferred: Deferred.Deferred<InstanceContext>
-}
-
-const layer: Layer.Layer<Service, never, Project.Service | InstanceBootstrap.Service> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const project = yield* Project.Service
-    const bootstrap = yield* InstanceBootstrap.Service
-    const scope = yield* Scope.Scope
-    const cache = new Map<string, Entry>()
-
-    const boot = (input: LoadInput & { directory: string }) =>
-      Effect.gen(function* () {
-        const ctx: InstanceContext =
-          input.project && input.worktree
-            ? {
-                directory: input.directory,
-                worktree: input.worktree,
-                project: input.project,
-              }
-            : yield* project.fromDirectory(input.directory).pipe(
-                Effect.map((result) => ({
-                  directory: input.directory,
-                  worktree: result.sandbox,
-                  project: result.project,
-                })),
-              )
-        yield* bootstrap.run.pipe(Effect.provideService(InstanceRef, ctx))
-        return ctx
-      }).pipe(Effect.withSpan("InstanceStore.boot"))
-
-    const removeEntry = (directory: string, entry: Entry) =>
-      Effect.sync(() => {
-        if (cache.get(directory) !== entry) return false
-        cache.delete(directory)
-        return true
-      })
-
-    const completeLoad = (directory: string, input: LoadInput, entry: Entry) =>
-      Effect.gen(function* () {
-        const exit = yield* Effect.exit(boot({ ...input, directory }))
-        if (Exit.isFailure(exit)) yield* removeEntry(directory, entry)
-        yield* Deferred.done(entry.deferred, exit).pipe(Effect.asVoid)
-      })
-
-    const emitDisposed = (input: { directory: string; project?: string }) =>
-      Effect.sync(() =>
-        GlobalBus.emit("event", {
-          directory: input.directory,
-          project: input.project,
-          workspace: WorkspaceContext.workspaceID,
-          payload: {
-            type: "server.instance.disposed",
-            properties: {
-              directory: input.directory,
-            },
-          },
-        }),
-      )
-
-    const disposeContext = Effect.fn("InstanceStore.disposeContext")(function* (ctx: InstanceContext) {
-      yield* Effect.logInfo("disposing instance", { directory: ctx.directory })
-      yield* Effect.promise(() => runDisposers(ctx.directory))
-      yield* emitDisposed({ directory: ctx.directory, project: ctx.project.id })
-    })
-
-    const disposeEntry = Effect.fnUntraced(function* (directory: string, entry: Entry, ctx: InstanceContext) {
-      if (cache.get(directory) !== entry) return false
-      yield* disposeContext(ctx)
-      if (cache.get(directory) !== entry) return false
-      cache.delete(directory)
-      return true
-    })
-
-    const load = (input: LoadInput): Effect.Effect<InstanceContext> => {
-      const directory = FSUtil.resolve(input.directory)
-      return Effect.uninterruptibleMask((restore) =>
-        Effect.gen(function* () {
-          const existing = cache.get(directory)
-          if (existing) return yield* restore(Deferred.await(existing.deferred))
-
-          const entry: Entry = { deferred: Deferred.makeUnsafe<InstanceContext>() }
-          cache.set(directory, entry)
-          yield* Effect.gen(function* () {
-            yield* Effect.logInfo("creating instance", { directory: directory })
-            yield* completeLoad(directory, input, entry)
-          }).pipe(Effect.forkIn(scope, { startImmediately: true }))
-          return yield* restore(Deferred.await(entry.deferred))
-        }),
-      ).pipe(Effect.withSpan("InstanceStore.load"))
-    }
-
-    const reload = (input: LoadInput): Effect.Effect<InstanceContext> => {
-      const directory = FSUtil.resolve(input.directory)
-      return Effect.uninterruptibleMask((restore) =>
-        Effect.gen(function* () {
-          const previous = cache.get(directory)
-          const entry: Entry = { deferred: Deferred.makeUnsafe<InstanceContext>() }
-          cache.set(directory, entry)
-          yield* Effect.gen(function* () {
-            yield* Effect.logInfo("reloading instance", { directory: directory })
-            if (previous) {
-              yield* Deferred.await(previous.deferred).pipe(Effect.ignore)
-              yield* Effect.promise(() => runDisposers(directory))
-              yield* emitDisposed({ directory, project: input.project?.id })
-            }
-            yield* completeLoad(directory, input, entry)
-          }).pipe(Effect.forkIn(scope, { startImmediately: true }))
-          return yield* restore(Deferred.await(entry.deferred))
-        }),
-      ).pipe(Effect.withSpan("InstanceStore.reload"))
-    }
-
-    const dispose = Effect.fn("InstanceStore.dispose")(function* (ctx: InstanceContext) {
-      const entry = cache.get(ctx.directory)
-      if (!entry) return yield* disposeContext(ctx)
-
-      const exit = yield* Deferred.await(entry.deferred).pipe(Effect.exit)
-      if (Exit.isFailure(exit)) return yield* removeEntry(ctx.directory, entry).pipe(Effect.asVoid)
-      if (exit.value !== ctx) return
-      yield* disposeEntry(ctx.directory, entry, ctx).pipe(Effect.asVoid)
-    })
-
-    const disposeDirectory = Effect.fn("InstanceStore.disposeDirectory")(function* (input: string) {
-      const directory = FSUtil.resolve(input)
-      const entry = cache.get(directory)
-      if (!entry) return
-      const exit = yield* Deferred.await(entry.deferred).pipe(Effect.exit)
-      if (Exit.isFailure(exit)) return yield* removeEntry(directory, entry).pipe(Effect.asVoid)
-      yield* disposeEntry(directory, entry, exit.value).pipe(Effect.asVoid)
-    })
-
-    const disposeAllOnce = Effect.fnUntraced(function* () {
-      yield* Effect.logInfo("disposing all instances")
-      yield* Effect.forEach(
-        [...cache.entries()],
-        (item) =>
-          Effect.gen(function* () {
-            const exit = yield* Deferred.await(item[1].deferred).pipe(Effect.exit)
-            if (Exit.isFailure(exit)) {
-              yield* Effect.logWarning("instance dispose failed", { key: item[0], cause: exit.cause })
-              yield* removeEntry(item[0], item[1])
-              return
-            }
-            yield* disposeEntry(item[0], item[1], exit.value)
-          }),
-        { discard: true },
-      )
-    })
-
-    const cachedDisposeAll = yield* Effect.cachedWithTTL(disposeAllOnce(), Duration.zero)
-    const disposeAll = Effect.fn("InstanceStore.disposeAll")(function* () {
-      return yield* cachedDisposeAll
-    })
-
-    const provide = <A, E, R>(input: LoadInput, effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-      load(input).pipe(Effect.flatMap((ctx) => effect.pipe(Effect.provideService(InstanceRef, ctx))))
-
-    yield* Effect.addFinalizer(() => disposeAll().pipe(Effect.ignore))
-
-    return Service.of({
-      load,
-      reload,
-      dispose,
-      disposeDirectory,
-      disposeAll,
-      provide,
-    })
-  }),
-)
-
-export const bootstrapNode = LayerNode.unbound(InstanceBootstrap.Service, Node.tags.values.global)
-
-export const node = makeGlobalNode({
-  service: Service,
-  layer: layer,
-  deps: [Project.node, bootstrapNode],
-})
-
-export * as InstanceStore from "./instance-store"