@neurocode-ai/core 1.18.8

package/test/effect/cross-spawn-spawner.test.ts

@@ -0,0 +1,426 @@
+import { describe, expect } from "bun:test"
+import fs from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { Effect, Exit, Stream } from "effect"
+import type * as PlatformError from "effect/PlatformError"
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
+import { CrossSpawnSpawner } from "@neurocode-ai/core/cross-spawn-spawner"
+import { LayerNode } from "@neurocode-ai/core/effect/layer-node"
+import { testEffect } from "../lib/effect"
+
+const live = LayerNode.compile(CrossSpawnSpawner.node)
+const fx = testEffect(live)
+
+function js(code: string, opts?: ChildProcess.CommandOptions) {
+  return ChildProcess.make("node", ["-e", code], opts)
+}
+
+function decodeByteStream(stream: Stream.Stream<Uint8Array, PlatformError.PlatformError>) {
+  return Stream.runCollect(stream).pipe(
+    Effect.map((chunks) => {
+      const total = chunks.reduce((acc, x) => acc + x.length, 0)
+      const out = new Uint8Array(total)
+      let off = 0
+      for (const chunk of chunks) {
+        out.set(chunk, off)
+        off += chunk.length
+      }
+      return new TextDecoder("utf-8").decode(out).trim()
+    }),
+  )
+}
+
+function alive(pid: number) {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function tmpdir() {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "neurocode-core-test-"))
+  return {
+    path: dir,
+    async [Symbol.asyncDispose]() {
+      await fs.rm(dir, { recursive: true, force: true })
+    },
+  }
+}
+
+async function gone(pid: number, timeout = 5_000) {
+  const end = Date.now() + timeout
+  while (Date.now() < end) {
+    if (!alive(pid)) return true
+    await new Promise((resolve) => setTimeout(resolve, 50))
+  }
+  return !alive(pid)
+}
+
+describe("cross-spawn spawner", () => {
+  describe("basic spawning", () => {
+    fx.effect(
+      "captures stdout",
+      Effect.gen(function* () {
+        const out = yield* ChildProcessSpawner.ChildProcessSpawner.use((svc) =>
+          svc.string(ChildProcess.make(process.execPath, ["-e", 'process.stdout.write("ok")'])),
+        )
+        expect(out).toBe("ok")
+      }),
+    )
+
+    fx.effect(
+      "captures multiple lines",
+      Effect.gen(function* () {
+        const handle = yield* js('console.log("line1"); console.log("line2"); console.log("line3")')
+        const out = yield* decodeByteStream(handle.stdout)
+        expect(out).toBe("line1\nline2\nline3")
+      }),
+    )
+
+    fx.effect(
+      "returns exit code",
+      Effect.gen(function* () {
+        const handle = yield* js("process.exit(0)")
+        const code = yield* handle.exitCode
+        expect(code).toBe(ChildProcessSpawner.ExitCode(0))
+      }),
+    )
+
+    fx.effect(
+      "returns non-zero exit code",
+      Effect.gen(function* () {
+        const handle = yield* js("process.exit(42)")
+        const code = yield* handle.exitCode
+        expect(code).toBe(ChildProcessSpawner.ExitCode(42))
+      }),
+    )
+  })
+
+  describe("cwd option", () => {
+    fx.effect(
+      "uses cwd when spawning commands",
+      Effect.gen(function* () {
+        const tmp = yield* Effect.acquireRelease(
+          Effect.promise(() => tmpdir()),
+          (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+        )
+        const out = yield* ChildProcessSpawner.ChildProcessSpawner.use((svc) =>
+          svc.string(
+            ChildProcess.make(process.execPath, ["-e", "process.stdout.write(process.cwd())"], { cwd: tmp.path }),
+          ),
+        )
+        expect(yield* Effect.promise(() => fs.realpath(out))).toBe(yield* Effect.promise(() => fs.realpath(tmp.path)))
+      }),
+    )
+
+    fx.effect(
+      "fails for invalid cwd",
+      Effect.gen(function* () {
+        const exit = yield* Effect.exit(
+          ChildProcessSpawner.ChildProcessSpawner.use((svc) =>
+            svc.spawn(ChildProcess.make("echo", ["test"], { cwd: "/nonexistent/directory/path" })),
+          ),
+        )
+        expect(Exit.isFailure(exit)).toBe(true)
+      }),
+    )
+  })
+
+  describe("env option", () => {
+    fx.effect(
+      "passes environment variables with extendEnv",
+      Effect.gen(function* () {
+        const handle = yield* js('process.stdout.write(process.env.TEST_VAR ?? "")', {
+          env: { TEST_VAR: "test_value" },
+          extendEnv: true,
+        })
+        const out = yield* decodeByteStream(handle.stdout)
+        expect(out).toBe("test_value")
+      }),
+    )
+
+    fx.effect(
+      "passes multiple environment variables",
+      Effect.gen(function* () {
+        const handle = yield* js(
+          "process.stdout.write(`${process.env.VAR1}-${process.env.VAR2}-${process.env.VAR3}`)",
+          {
+            env: { VAR1: "one", VAR2: "two", VAR3: "three" },
+            extendEnv: true,
+          },
+        )
+        const out = yield* decodeByteStream(handle.stdout)
+        expect(out).toBe("one-two-three")
+      }),
+    )
+  })
+
+  describe("stderr", () => {
+    fx.effect(
+      "captures stderr output",
+      Effect.gen(function* () {
+        const handle = yield* js('process.stderr.write("error message")')
+        const err = yield* decodeByteStream(handle.stderr)
+        expect(err).toBe("error message")
+      }),
+    )
+
+    fx.effect(
+      "captures both stdout and stderr",
+      Effect.gen(function* () {
+        const handle = yield* js(
+          [
+            "let pending = 2",
+            "const done = () => {",
+            "  pending -= 1",
+            "  if (pending === 0) setTimeout(() => process.exit(0), 0)",
+            "}",
+            'process.stdout.write("stdout\\n", done)',
+            'process.stderr.write("stderr\\n", done)',
+          ].join("\n"),
+        )
+        const [stdout, stderr] = yield* Effect.all([decodeByteStream(handle.stdout), decodeByteStream(handle.stderr)], {
+          concurrency: 2,
+        })
+        expect(stdout).toBe("stdout")
+        expect(stderr).toBe("stderr")
+      }),
+    )
+  })
+
+  describe("combined output (all)", () => {
+    fx.effect(
+      "captures stdout via .all when no stderr",
+      Effect.gen(function* () {
+        const handle = yield* ChildProcess.make("echo", ["hello from stdout"])
+        const all = yield* decodeByteStream(handle.all)
+        expect(all).toBe("hello from stdout")
+      }),
+    )
+
+    fx.effect(
+      "captures stderr via .all when no stdout",
+      Effect.gen(function* () {
+        const handle = yield* js('process.stderr.write("hello from stderr")')
+        const all = yield* decodeByteStream(handle.all)
+        expect(all).toBe("hello from stderr")
+      }),
+    )
+  })
+
+  describe("stdin", () => {
+    fx.effect(
+      "allows providing standard input to a command",
+      Effect.gen(function* () {
+        const input = "a b c"
+        const stdin = Stream.make(Buffer.from(input, "utf-8"))
+        const handle = yield* js(
+          'process.stdin.setEncoding("utf8"); let out = ""; process.stdin.on("data", (chunk) => out += chunk); process.stdin.on("end", () => process.stdout.write(out))',
+          { stdin },
+        )
+        const out = yield* decodeByteStream(handle.stdout)
+        yield* handle.exitCode
+        expect(out).toBe("a b c")
+      }),
+    )
+  })
+
+  describe("process control", () => {
+    fx.effect(
+      "kills a running process",
+      Effect.gen(function* () {
+        const exit = yield* Effect.exit(
+          Effect.gen(function* () {
+            const handle = yield* js("setTimeout(() => {}, 10_000)")
+            yield* handle.kill()
+            return yield* handle.exitCode
+          }),
+        )
+        expect(Exit.isFailure(exit) ? true : exit.value !== ChildProcessSpawner.ExitCode(0)).toBe(true)
+      }),
+    )
+
+    fx.effect(
+      "kills a child when scope exits",
+      Effect.gen(function* () {
+        const pid = yield* Effect.scoped(
+          Effect.gen(function* () {
+            const handle = yield* js("setInterval(() => {}, 10_000)")
+            return Number(handle.pid)
+          }),
+        )
+        const done = yield* Effect.promise(() => gone(pid))
+        expect(done).toBe(true)
+      }),
+    )
+
+    fx.effect(
+      "forceKillAfter escalates for stubborn processes",
+      Effect.gen(function* () {
+        if (process.platform === "win32") return
+
+        const started = Date.now()
+        const exit = yield* Effect.exit(
+          Effect.gen(function* () {
+            const handle = yield* js('process.on("SIGTERM", () => {}); setInterval(() => {}, 10_000)')
+            yield* handle.kill({ forceKillAfter: 100 })
+            return yield* handle.exitCode
+          }),
+        )
+
+        expect(Date.now() - started).toBeLessThan(1_000)
+        expect(Exit.isFailure(exit) ? true : exit.value !== ChildProcessSpawner.ExitCode(0)).toBe(true)
+      }),
+    )
+
+    fx.effect(
+      "isRunning reflects process state",
+      Effect.gen(function* () {
+        const handle = yield* js('process.stdout.write("done")')
+        yield* handle.exitCode
+        const running = yield* handle.isRunning
+        expect(running).toBe(false)
+      }),
+    )
+  })
+
+  describe("error handling", () => {
+    fx.effect(
+      "fails for invalid command",
+      Effect.gen(function* () {
+        const exit = yield* Effect.exit(
+          Effect.gen(function* () {
+            const handle = yield* ChildProcess.make("nonexistent-command-12345")
+            return yield* handle.exitCode
+          }),
+        )
+        expect(Exit.isFailure(exit) ? true : exit.value !== ChildProcessSpawner.ExitCode(0)).toBe(true)
+      }),
+    )
+  })
+
+  describe("pipeline", () => {
+    fx.effect(
+      "pipes stdout of one command to stdin of another",
+      Effect.gen(function* () {
+        const handle = yield* js('process.stdout.write("hello world")').pipe(
+          ChildProcess.pipeTo(
+            js(
+              'process.stdin.setEncoding("utf8"); let out = ""; process.stdin.on("data", (chunk) => out += chunk); process.stdin.on("end", () => process.stdout.write(out.toUpperCase()))',
+            ),
+          ),
+        )
+        const out = yield* decodeByteStream(handle.stdout)
+        yield* handle.exitCode
+        expect(out).toBe("HELLO WORLD")
+      }),
+    )
+
+    fx.effect(
+      "three-stage pipeline",
+      Effect.gen(function* () {
+        const handle = yield* js('process.stdout.write("hello world")').pipe(
+          ChildProcess.pipeTo(
+            js(
+              'process.stdin.setEncoding("utf8"); let out = ""; process.stdin.on("data", (chunk) => out += chunk); process.stdin.on("end", () => process.stdout.write(out.toUpperCase()))',
+            ),
+          ),
+          ChildProcess.pipeTo(
+            js(
+              'process.stdin.setEncoding("utf8"); let out = ""; process.stdin.on("data", (chunk) => out += chunk); process.stdin.on("end", () => process.stdout.write(out.replaceAll(" ", "-")))',
+            ),
+          ),
+        )
+        const out = yield* decodeByteStream(handle.stdout)
+        yield* handle.exitCode
+        expect(out).toBe("HELLO-WORLD")
+      }),
+    )
+
+    fx.effect(
+      "pipes stderr with { from: 'stderr' }",
+      Effect.gen(function* () {
+        const handle = yield* js('process.stderr.write("error")').pipe(
+          ChildProcess.pipeTo(
+            js(
+              'process.stdin.setEncoding("utf8"); let out = ""; process.stdin.on("data", (chunk) => out += chunk); process.stdin.on("end", () => process.stdout.write(out))',
+            ),
+            { from: "stderr" },
+          ),
+        )
+        const out = yield* decodeByteStream(handle.stdout)
+        yield* handle.exitCode
+        expect(out).toBe("error")
+      }),
+    )
+
+    fx.effect(
+      "pipes combined output with { from: 'all' }",
+      Effect.gen(function* () {
+        const handle = yield* js('process.stdout.write("stdout\\n"); process.stderr.write("stderr\\n")').pipe(
+          ChildProcess.pipeTo(
+            js(
+              'process.stdin.setEncoding("utf8"); let out = ""; process.stdin.on("data", (chunk) => out += chunk); process.stdin.on("end", () => process.stdout.write(out))',
+            ),
+            { from: "all" },
+          ),
+        )
+        const out = yield* decodeByteStream(handle.stdout)
+        yield* handle.exitCode
+        expect(out).toContain("stdout")
+        expect(out).toContain("stderr")
+      }),
+    )
+  })
+
+  describe("Windows-specific", () => {
+    fx.effect(
+      "uses shell routing on Windows",
+      Effect.gen(function* () {
+        if (process.platform !== "win32") return
+
+        const out = yield* ChildProcessSpawner.ChildProcessSpawner.use((svc) =>
+          svc.string(
+            ChildProcess.make("set", ["NEUROCODE_TEST_SHELL"], {
+              shell: true,
+              extendEnv: true,
+              env: { NEUROCODE_TEST_SHELL: "ok" },
+            }),
+          ),
+        )
+        expect(out).toContain("NEUROCODE_TEST_SHELL=ok")
+      }),
+    )
+
+    fx.effect(
+      "runs cmd scripts with spaces on Windows without shell",
+      Effect.gen(function* () {
+        if (process.platform !== "win32") return
+
+        const tmp = yield* Effect.acquireRelease(
+          Effect.promise(() => tmpdir()),
+          (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+        )
+        const dir = path.join(tmp.path, "with space")
+        const file = path.join(dir, "echo cmd.cmd")
+
+        yield* Effect.promise(() => fs.mkdir(dir, { recursive: true }))
+        yield* Effect.promise(() => fs.writeFile(file, "@echo off\r\nif %~1==--stdio exit /b 0\r\nexit /b 7\r\n"))
+
+        const code = yield* ChildProcessSpawner.ChildProcessSpawner.use((svc) =>
+          svc.exitCode(
+            ChildProcess.make(file, ["--stdio"], {
+              stdin: "pipe",
+              stdout: "pipe",
+              stderr: "pipe",
+            }),
+          ),
+        )
+        expect(code).toBe(ChildProcessSpawner.ExitCode(0))
+      }),
+    )
+  })
+})

package/test/effect/keyed-mutex.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect } from "bun:test"
+import { Deferred, Effect, Fiber } from "effect"
+import { KeyedMutex } from "@neurocode-ai/core/effect/keyed-mutex"
+import { it } from "../lib/effect"
+
+describe("KeyedMutex", () => {
+  it.effect("serializes effects with the same key", () =>
+    Effect.gen(function* () {
+      const mutex = yield* KeyedMutex.make<string>()
+      const firstStarted = yield* Deferred.make<void>()
+      const releaseFirst = yield* Deferred.make<void>()
+      const secondStarted = yield* Deferred.make<void>()
+
+      const first = yield* mutex
+        .withLock("shared")(
+          Deferred.succeed(firstStarted, undefined).pipe(Effect.andThen(Deferred.await(releaseFirst))),
+        )
+        .pipe(Effect.forkChild)
+      yield* Deferred.await(firstStarted)
+      const second = yield* mutex.withLock("shared")(Deferred.succeed(secondStarted, undefined)).pipe(Effect.forkChild)
+      yield* Effect.yieldNow
+      expect(yield* Deferred.isDone(secondStarted)).toBe(false)
+
+      yield* Deferred.succeed(releaseFirst, undefined)
+      yield* Fiber.join(first)
+      yield* Fiber.join(second)
+      expect(yield* mutex.size).toBe(0)
+    }),
+  )
+
+  it.effect("allows different keys to proceed independently", () =>
+    Effect.gen(function* () {
+      const mutex = yield* KeyedMutex.make<string>()
+      const firstStarted = yield* Deferred.make<void>()
+      const releaseFirst = yield* Deferred.make<void>()
+      const secondFinished = yield* Deferred.make<void>()
+
+      const first = yield* mutex
+        .withLock("first")(Deferred.succeed(firstStarted, undefined).pipe(Effect.andThen(Deferred.await(releaseFirst))))
+        .pipe(Effect.forkChild)
+      yield* Deferred.await(firstStarted)
+      yield* mutex.withLock("second")(Deferred.succeed(secondFinished, undefined))
+      expect(yield* Deferred.isDone(secondFinished)).toBe(true)
+
+      yield* Deferred.succeed(releaseFirst, undefined)
+      yield* Fiber.join(first)
+      expect(yield* mutex.size).toBe(0)
+    }),
+  )
+
+  it.effect("removes an interrupted waiter without dropping the holder lock", () =>
+    Effect.gen(function* () {
+      const mutex = yield* KeyedMutex.make<string>()
+      const firstStarted = yield* Deferred.make<void>()
+      const releaseFirst = yield* Deferred.make<void>()
+
+      const first = yield* mutex
+        .withLock("shared")(
+          Deferred.succeed(firstStarted, undefined).pipe(Effect.andThen(Deferred.await(releaseFirst))),
+        )
+        .pipe(Effect.forkChild)
+      yield* Deferred.await(firstStarted)
+      const interrupted = yield* mutex.withLock("shared")(Effect.void).pipe(Effect.forkChild)
+      yield* Effect.yieldNow
+      yield* Fiber.interrupt(interrupted)
+      expect(yield* mutex.size).toBe(1)
+
+      yield* Deferred.succeed(releaseFirst, undefined)
+      yield* Fiber.join(first)
+      expect(yield* mutex.size).toBe(0)
+    }),
+  )
+})

package/test/effect/layer-node/layer-node-types.test.ts

@@ -0,0 +1,143 @@
+import { test } from "bun:test"
+import { Context, Effect, Layer } from "effect"
+import { LayerNode } from "@neurocode-ai/core/effect/layer-node"
+import { makeGlobalNode, makeLocationNode } from "@neurocode-ai/core/effect/app-node"
+
+class A extends Context.Service<A, {}>()("test/LayerNodeA") {}
+class B extends Context.Service<B, {}>()("test/LayerNodeB") {}
+class C extends Context.Service<C, {}>()("test/LayerNodeC") {}
+class LayerError {
+  readonly _tag = "LayerError"
+}
+class OtherError {
+  readonly _tag = "OtherError"
+}
+
+const tags = LayerNode.tags({ app: [] })
+const make = tags.make("app")
+const build = <A, E>(root: LayerNode.Node<A, E, any>) => LayerNode.compile(root) as Layer.Layer<A, E>
+const aLayer = Layer.succeed(A, A.of({}))
+const bLayer = Layer.effect(B, Effect.as(A, B.of({})))
+const cLayer = Layer.effect(
+  C,
+  Effect.gen(function* () {
+    yield* A
+    yield* B
+    return C.of({})
+  }),
+)
+const failingA = Layer.effect(A, Effect.fail(new LayerError()))
+const a = make({ service: A, layer: aLayer, deps: [] })
+const b = make({ service: B, layer: bLayer, deps: [a] })
+const c = make({ service: C, layer: cLayer, deps: [a, b] })
+const failing = make({ service: A, layer: failingA, deps: [] })
+const dependent = make({ service: B, layer: bLayer, deps: [failing] })
+const inputA = LayerNode.unbound(A, tags.values.app)
+const inputDependent = make({ service: B, layer: bLayer, deps: [inputA] })
+
+make({ name: "manual-a", layer: aLayer, deps: [] })
+
+// @ts-expect-error A node must have a service or name
+make({ layer: aLayer, deps: [] })
+
+// @ts-expect-error Service and name are mutually exclusive
+make({ service: A, name: "a", layer: aLayer, deps: [] })
+
+// @ts-expect-error B requires A
+make({ service: B, layer: bLayer, deps: [] })
+
+// @ts-expect-error C requires A and B
+make({ service: C, layer: cLayer, deps: [a] })
+
+const closed = build(LayerNode.group([c]))
+const closedWithError = build(LayerNode.group([dependent]))
+const checkClosed: Layer.Layer<C, never, never> = closed
+const checkError: Layer.Layer<B, LayerError, never> = closedWithError
+void checkClosed
+void checkError
+
+LayerNode.compile(a, [[a, Layer.succeed(A, A.of({}))]])
+LayerNode.compile(a, [[a, make({ service: A, layer: Layer.succeed(A, A.of({})), deps: [] })]])
+
+// @ts-expect-error Replacement must provide A
+LayerNode.compile(a, [[a, Layer.succeed(B, B.of({}))]])
+
+// @ts-expect-error Node replacement must provide A
+const invalidNodeReplacement = () => LayerNode.compile(a, [[a, b]])
+void invalidNodeReplacement
+
+// @ts-expect-error Replacement cannot introduce a new error
+LayerNode.compile(a, [[a, Layer.effect(A, Effect.fail(new OtherError()))]])
+
+const invalidNodeErrorReplacement = () =>
+  // @ts-expect-error Node replacement cannot introduce a new error
+  LayerNode.compile(a, [[a, make({ service: A, layer: Layer.effect(A, Effect.fail(new OtherError())), deps: [] })]])
+void invalidNodeErrorReplacement
+
+class TagA extends Context.Service<TagA, {}>()("test/TagA") {}
+class TagB extends Context.Service<TagB, {}>()("test/TagB") {}
+class TagC extends Context.Service<TagC, {}>()("test/TagC") {}
+
+const scopedTags = LayerNode.tags({ request: ["global"], global: [] })
+const request = scopedTags.make("request")
+const global = scopedTags.make("global")
+const globalA = global({ service: TagA, layer: Layer.succeed(TagA, TagA.of({})), deps: [] })
+const requestA = request({ service: TagA, layer: Layer.succeed(TagA, TagA.of({})), deps: [] })
+const requestB = request({ service: TagB, layer: Layer.succeed(TagB, TagB.of({})), deps: [] })
+const tagBLayer = Layer.effect(TagB, Effect.as(TagA, TagB.of({})))
+const tagCLayer = Layer.effect(
+  TagC,
+  Effect.gen(function* () {
+    yield* TagA
+    yield* TagB
+    return TagC.of({})
+  }),
+)
+
+request({ service: TagB, layer: tagBLayer, deps: [globalA] })
+request({ service: TagC, layer: tagCLayer, deps: [globalA, requestB] })
+request({ service: TagC, layer: tagCLayer, deps: [LayerNode.group([globalA, requestB])] })
+
+// @ts-expect-error Tag configuration can only reference declared tags
+LayerNode.tags({ request: ["missing"], global: [] })
+
+// @ts-expect-error An unrelated dependency cannot satisfy TagA
+request({ service: TagB, layer: tagBLayer, deps: [requestB] })
+
+// @ts-expect-error Providing only TagA leaves TagB missing
+request({ service: TagC, layer: tagCLayer, deps: [globalA] })
+
+// @ts-expect-error Providing only TagB leaves TagA missing
+request({ service: TagC, layer: tagCLayer, deps: [requestB] })
+
+// @ts-expect-error Duplicate TagA providers still leave TagB missing
+request({ service: TagC, layer: tagCLayer, deps: [globalA, requestA] })
+
+// @ts-expect-error A group with only TagA still leaves TagB missing
+request({ service: TagC, layer: tagCLayer, deps: [LayerNode.group([globalA])] })
+
+// @ts-expect-error Global cannot depend on request
+global({ service: TagB, layer: tagBLayer, deps: [requestA] })
+
+// @ts-expect-error Groups preserve their child tags
+global({ service: TagB, layer: tagBLayer, deps: [LayerNode.group([requestA])] })
+
+class ScopedA extends Context.Service<ScopedA, {}>()("test/ScopedA") {}
+class ScopedB extends Context.Service<ScopedB, {}>()("test/ScopedB") {}
+
+const scopedA = Layer.succeed(ScopedA, ScopedA.of({}))
+const scopedB = Layer.effect(ScopedB, Effect.as(ScopedA, ScopedB.of({})))
+const globalScopedA = makeGlobalNode({ service: ScopedA, layer: scopedA, deps: [] })
+const locationScopedA = makeLocationNode({ service: ScopedA, layer: scopedA, deps: [] })
+
+makeGlobalNode({ service: ScopedB, layer: scopedB, deps: [globalScopedA] })
+makeLocationNode({ service: ScopedB, layer: scopedB, deps: [globalScopedA] })
+makeLocationNode({ service: ScopedB, layer: scopedB, deps: [locationScopedA] })
+
+// @ts-expect-error Global nodes cannot depend on location nodes
+makeGlobalNode({ service: ScopedB, layer: scopedB, deps: [locationScopedA] })
+
+// @ts-expect-error ScopedB requires ScopedA
+makeLocationNode({ service: ScopedB, layer: scopedB, deps: [] })
+
+test("type exploration compiles", () => {})