trace npm fully

packages/opencode/src/effect/app-runtime.ts

@@ -1,5 +1,5 @@
 import { Layer, ManagedRuntime } from "effect"
-import { attach, memoMap } from "./run-service"
+import { attach } from "./run-service"
 import * as Observability from "./observability"
 
 import { AppFileSystem } from "@opencode-ai/shared/filesystem"
@@ -46,7 +46,8 @@ import { Pty } from "@/pty"
 import { Installation } from "@/installation"
 import { ShareNext } from "@/share"
 import { SessionShare } from "@/share"
-import { Npm } from "@opencode-ai/shared/npm"
+import { Npm } from "@/npm/effect"
+import { memoMap } from "./memo-map"
 
 export const AppLayer = Layer.mergeAll(
   Npm.defaultLayer,

packages/opencode/src/effect/bootstrap-runtime.ts

@@ -1,5 +1,4 @@
 import { Layer, ManagedRuntime } from "effect"
-import { memoMap } from "./run-service"
 
 import { Plugin } from "@/plugin"
 import { LSP } from "@/lsp"
@@ -12,6 +11,7 @@ import { Snapshot } from "@/snapshot"
 import { Bus } from "@/bus"
 import { Config } from "@/config"
 import * as Observability from "./observability"
+import { memoMap } from "./memo-map"
 
 export const BootstrapLayer = Layer.mergeAll(
   Config.defaultLayer,

packages/opencode/src/effect/memo-map.ts

@@ -0,0 +1,3 @@
+import { Layer } from "effect"
+
+export const memoMap = Layer.makeMemoMapUnsafe()

packages/opencode/src/effect/run-service.ts

@@ -6,8 +6,7 @@ import { InstanceRef, WorkspaceRef } from "./instance-ref"
 import * as Observability from "./observability"
 import { WorkspaceContext } from "@/control-plane/workspace-context"
 import type { InstanceContext } from "@/project/instance"
-
-export const memoMap = Layer.makeMemoMapUnsafe()
+import { memoMap } from "./memo-map"
 
 type Refs = {
   instance?: InstanceContext

packages/opencode/src/effect/runtime.ts

@@ -0,0 +1,19 @@
+import { Observability } from "./observability"
+import { Layer, type Context, ManagedRuntime, type Effect } from "effect"
+import { memoMap } from "./memo-map"
+
+export function makeRuntime<I, S, E>(service: Context.Service<I, S>, layer: Layer.Layer<I, E>) {
+  let rt: ManagedRuntime.ManagedRuntime<I, E> | undefined
+  const getRuntime = () =>
+    (rt ??= ManagedRuntime.make(Layer.provideMerge(layer, Observability.layer) as Layer.Layer<I, E>, { memoMap }))
+
+  return {
+    runSync: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => getRuntime().runSync(service.use(fn)),
+    runPromiseExit: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>, options?: Effect.RunOptions) =>
+      getRuntime().runPromiseExit(service.use(fn), options),
+    runPromise: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>, options?: Effect.RunOptions) =>
+      getRuntime().runPromise(service.use(fn), options),
+    runFork: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => getRuntime().runFork(service.use(fn)),
+    runCallback: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => getRuntime().runCallback(service.use(fn)),
+  }
+}