@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-45smdebh.js

@@ -0,0 +1,145 @@
+import {
+  ephemeral2,
+  Service79,
+  node84
+} from "./aisdk-native-11nvngjf.js";
+import {
+  Key3,
+  unavailable3,
+  removed2,
+  make20,
+  diffByKey2
+} from "./aisdk-native-rhjbct0v.js";
+import {
+  AbsolutePath2
+} from "./aisdk-native-922hggd3.js";
+import {
+  create3
+} from "./aisdk-native-kg06axw8.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/instruction-discovery.ts
+var exports_instruction_discovery = {};
+__export(exports_instruction_discovery, {
+  Event: () => Event7,
+  File: () => File2,
+  InstructionDiscovery: () => exports_instruction_discovery,
+  Options: () => Options7,
+  Service: () => Service48,
+  configured: () => configured6,
+  layer: () => layer19,
+  node: () => node51
+});
+import { Context, Effect, Layer, Schema } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { createPatch } from "diff";
+class File2 extends Schema.Class("InstructionDiscovery.File")({
+  path: AbsolutePath2,
+  content: Schema.String
+}) {
+}
+var Files = Schema.Array(File2);
+var key = Key3.make("core/instructions");
+var Event7 = {
+  Updated: ephemeral2({ type: "instruction-discovery.updated", schema: {} })
+};
+var Options7 = Schema.Struct({
+  project: Schema.optional(Schema.Boolean),
+  global: Schema.optional(Schema.Boolean)
+});
+
+class Service48 extends Context.Service()("@opencode/InstructionDiscovery") {
+}
+var layer19 = (options) => Layer.effect(Service48, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const state = create3({
+    name: "instruction-discovery",
+    initial: () => ({ files: new Map, available: true }),
+    editor: (editor) => ({
+      list: () => Array.from(editor.files.values()),
+      add: (file) => editor.files.set(file.path, new File2(file)),
+      update: (path, update) => {
+        const current = editor.files.get(AbsolutePath2.make(path));
+        if (!current)
+          return;
+        update(current);
+        current.path = AbsolutePath2.make(path);
+      },
+      remove: (path) => editor.files.delete(AbsolutePath2.make(path)),
+      unavailable: () => {
+        editor.available = false;
+      }
+    }),
+    notify: () => bus.publish(Event7.Updated, {}).pipe(Effect.asVoid)
+  });
+  const source = (value) => make20({
+    key,
+    codec: Schema.toCodecJson(Files),
+    read: Effect.succeed(value),
+    render: {
+      initial: render,
+      changed: renderUpdate,
+      removed: () => "Previously loaded instructions no longer apply."
+    }
+  });
+  const list = Effect.fn("InstructionDiscovery.list")(function* () {
+    const current = state.get();
+    if (!current.available)
+      return unavailable3;
+    return Array.from(current.files.values());
+  });
+  return Service48.of({
+    project: options?.project !== false,
+    global: options?.global !== false,
+    transform: state.transform,
+    reload: state.reload,
+    list,
+    load: Effect.fn("InstructionDiscovery.load")(function* () {
+      const files = yield* list();
+      if (!Array.isArray(files))
+        return source(files);
+      return source(files.length === 0 ? removed2 : files);
+    })
+  });
+}));
+function configured6(options) {
+  return makeLocationNode({
+    service: Service48,
+    layer: layer19(options),
+    deps: [node84]
+  });
+}
+var node51 = configured6();
+function render(files) {
+  return files.map((file) => `Instructions from: ${file.path}
+${file.content}`).join(`
+
+`);
+}
+function renderUpdate(previous, current) {
+  const changes = diffByKey2(previous, current, (file) => file.path, (before, after) => before.content !== after.content);
+  return [
+    ...changes.removed.map((file) => `The instructions from ${file.path} no longer apply.`),
+    ...changes.added.map((file) => `New instructions apply from:
+${render([file])}`),
+    ...changes.changed.map(({ previous: before, current: after }) => {
+      const patch = createPatch(after.path, before.content, after.content, "", "", { context: 3 });
+      const diff = [
+        `The instructions from ${after.path} changed. Here's the diff:`,
+        "```diff",
+        patch.slice(patch.indexOf("@@")).trimEnd(),
+        "```"
+      ].join(`
+`);
+      const replacement = `The instructions changed:
+${render([after])}`;
+      return diff.length < replacement.length ? diff : replacement;
+    })
+  ].join(`
+
+`);
+}
+
+export { File2, Event7, Options7, Service48, layer19, configured6, node51, exports_instruction_discovery };

package/dist/chunks/aisdk-native-467byya2.js

@@ -0,0 +1,59 @@
+import {
+  AbsolutePath2
+} from "./aisdk-native-922hggd3.js";
+import {
+  Service73
+} from "./aisdk-native-6fyvx278.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/config/discovery.ts
+var exports_discovery2 = {};
+__export(exports_discovery2, {
+  ConfigDiscovery: () => exports_discovery2,
+  discover: () => discover3,
+  names: () => names4
+});
+import path from "path";
+import { Effect } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+var names4 = ["opencode.json", "opencode.jsonc"];
+var discover3 = Effect.fn("ConfigDiscovery.discover")(function* (options) {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const location = yield* Service73;
+  const globalDirectory = AbsolutePath2.make(global.config);
+  const globalAgentsDirectory = AbsolutePath2.make(path.join(global.home, ".agents"));
+  const globalClaudeDirectory = AbsolutePath2.make(path.join(global.home, ".claude"));
+  const globalRoots = yield* Effect.forEach([globalDirectory, globalClaudeDirectory, globalAgentsDirectory], (item) => fs.resolve(item));
+  const directories = (yield* fs.resolve(location.directory)) === globalRoots[0] || options?.project === false ? [] : yield* fs.up({ targets: ["."], start: location.directory }).pipe(Effect.orDie);
+  const discovered = yield* Effect.forEach(directories, (directory) => Effect.gen(function* () {
+    const parent = yield* fs.resolve(directory);
+    return yield* Effect.forEach([".claude", ".agents", ".opencode", ...names4.toReversed()], (name) => fs.resolve(path.join(parent, name)).pipe(Effect.map((resolved) => ({ item: AbsolutePath2.make(path.join(directory, name)), resolved }))));
+  })).pipe(Effect.map((items) => items.flat()), Effect.orDie);
+  const globalEnabled = options?.global !== false;
+  const globalFiles = yield* Effect.forEach(names4, (name) => fs.resolve(path.join(globalDirectory, name)));
+  const visible = discovered.filter(({ resolved }) => globalEnabled ? !globalRoots.includes(resolved) && !globalFiles.includes(resolved) : !globalRoots.some((root) => resolved === root || resolved.startsWith(root + path.sep))).map(({ item }) => item);
+  return {
+    global: globalEnabled ? globalDirectory : undefined,
+    explicit: options?.file ? AbsolutePath2.make(path.resolve(options.file)) : undefined,
+    direct: visible.filter((item) => ![".agents", ".claude", ".opencode"].includes(path.basename(item))).toReversed(),
+    project: yield* Effect.forEach(visible.filter((item) => path.basename(item) === ".opencode").toReversed(), (directory) => fs.isDir(directory).pipe(Effect.map((present) => ({ path: directory, present })))),
+    claude: [
+      ...new Set([
+        ...globalEnabled ? [globalClaudeDirectory] : [],
+        ...visible.filter((item) => path.basename(item) === ".claude").toReversed()
+      ])
+    ],
+    agents: [
+      ...new Set([
+        ...globalEnabled ? [globalAgentsDirectory] : [],
+        ...visible.filter((item) => path.basename(item) === ".agents").toReversed()
+      ])
+    ]
+  };
+});
+
+export { names4, discover3, exports_discovery2 };

package/dist/chunks/aisdk-native-4b9mceyk.js

@@ -0,0 +1,96 @@
+import {
+  Service73,
+  node78
+} from "./aisdk-native-6fyvx278.js";
+import {
+  create3
+} from "./aisdk-native-kg06axw8.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/formatter.ts
+var exports_formatter2 = {};
+__export(exports_formatter2, {
+  Formatter: () => exports_formatter2,
+  Service: () => Service18,
+  node: () => node21
+});
+import { Context, Effect, Layer } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import path from "path";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { AppProcess } from "@opencode/util/process";
+class Service18 extends Context.Service()("@opencode/v2/Formatter") {
+}
+var layer = Layer.effect(Service18, Effect.gen(function* () {
+  const location = yield* Service73;
+  const processes = yield* AppProcess.Service;
+  const commands = new WeakMap;
+  const state = create3({
+    name: "formatter",
+    initial: () => ({ formatters: [] }),
+    editor: (editor) => ({
+      set: (formatter) => {
+        const index = editor.formatters.findIndex((item) => item.name === formatter.name);
+        if (index === -1)
+          editor.formatters.push(formatter);
+        else
+          editor.formatters[index] = formatter;
+      },
+      remove: (name) => {
+        editor.formatters = editor.formatters.filter((formatter) => formatter.name !== name);
+      }
+    })
+  });
+  const command = Effect.fnUntraced(function* (formatter) {
+    const cached = commands.get(formatter);
+    if (cached !== undefined)
+      return cached;
+    const result = yield* formatter.enabled;
+    if (result !== false)
+      commands.set(formatter, result);
+    return result;
+  });
+  const file = Effect.fn("Formatter.file")(function* (filepath) {
+    const extension = path.extname(filepath);
+    const matching = state.get().formatters.filter((formatter) => formatter.extensions.includes(extension));
+    for (const formatter of matching) {
+      const enabled = yield* command(formatter);
+      if (enabled === false)
+        continue;
+      const cmd = enabled.map((argument) => argument.replace("$FILE", filepath));
+      yield* Effect.logInfo("formatting file", { file: filepath, command: cmd });
+      const result = yield* processes.run(ChildProcess.make(cmd[0], cmd.slice(1), {
+        cwd: location.directory,
+        env: formatter.environment,
+        extendEnv: true,
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "ignore"
+      })).pipe(Effect.catch((error) => Effect.logError("failed to format file", {
+        file: filepath,
+        command: cmd,
+        error: error.message
+      }).pipe(Effect.as(undefined))));
+      if (!result)
+        continue;
+      if (result.exitCode === 0)
+        return true;
+      yield* Effect.logError("formatter exited unsuccessfully", {
+        file: filepath,
+        command: cmd,
+        exitCode: result.exitCode
+      });
+    }
+    return false;
+  });
+  return Service18.of({ transform: state.transform, reload: state.reload, file });
+}));
+var node21 = makeLocationNode({
+  service: Service18,
+  layer,
+  deps: [node78, AppProcess.node]
+});
+
+export { Service18, node21, exports_formatter2 };

package/dist/chunks/aisdk-native-4exee4de.js

@@ -0,0 +1,49 @@
+import {
+  Service75
+} from "./aisdk-native-7zdm33ac.js";
+import {
+  DirectoryUnavailableError2,
+  canonical3
+} from "./aisdk-native-th5km1p3.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/worktree/git.ts
+var exports_git2 = {};
+__export(exports_git2, {
+  WorktreeGit: () => exports_git2,
+  make: () => make18
+});
+import { Effect } from "effect";
+import { Worktree } from "@opencode/schema/worktree";
+import { FSUtil } from "@opencode/util/fs-util";
+var make18 = Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const git = yield* Service75;
+  return {
+    id: Worktree.StrategyID.make("git"),
+    create: Effect.fn("Worktree.Git.create")(function* (input) {
+      const repository = yield* git.repo.discover(input.sourceDirectory);
+      if (!repository)
+        return yield* new DirectoryUnavailableError2({ directory: input.sourceDirectory });
+      yield* git.worktree.create({ repository, directory: input.directory, ref: input.branch });
+      return { directory: yield* canonical3(fs, input.directory) };
+    }),
+    remove: Effect.fn("Worktree.Git.remove")(function* (input) {
+      const repository = yield* git.repo.discover(input.directory);
+      if (!repository)
+        return yield* new DirectoryUnavailableError2({ directory: input.directory });
+      yield* git.worktree.remove({ repository, directory: input.directory, force: input.force });
+    }),
+    list: Effect.fn("Worktree.Git.list")(function* (directory) {
+      const repository = yield* git.repo.discover(directory);
+      if (!repository)
+        return yield* new DirectoryUnavailableError2({ directory });
+      const entries = yield* git.worktree.list(repository);
+      return yield* Effect.forEach(entries, (entry) => canonical3(fs, entry.directory).pipe(Effect.map((directory) => ({ directory, type: entry.kind === "main" ? "root" : "worktree" })), Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.undefined))).pipe(Effect.map((items) => items.filter((item) => item !== undefined)));
+    })
+  };
+});
+
+export { make18, exports_git2 };

package/dist/chunks/aisdk-native-4kkrbspp.js

@@ -0,0 +1,226 @@
+import {
+  Service79,
+  node84
+} from "./aisdk-native-11nvngjf.js";
+import {
+  node40
+} from "./aisdk-native-39dcxt5x.js";
+import {
+  Service3,
+  node6
+} from "./aisdk-native-w69f1nhp.js";
+import {
+  Service27
+} from "./aisdk-native-1x11rq2a.js";
+import {
+  node22,
+  ID3
+} from "./aisdk-native-33f8ypwy.js";
+import {
+  Service5,
+  node8
+} from "./aisdk-native-844ef7ks.js";
+import {
+  requirements2,
+  list2
+} from "./aisdk-native-sembr0kd.js";
+import {
+  make4,
+  LoadError2
+} from "./aisdk-native-v6yxqhem.js";
+import {
+  Updated2,
+  Service6,
+  node9
+} from "./aisdk-native-xbfgt74t.js";
+import {
+  Service4,
+  node7
+} from "./aisdk-native-jwx4y25k.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/plugin/supervisor.ts
+var exports_supervisor = {};
+__export(exports_supervisor, {
+  PluginSupervisor: () => exports_supervisor,
+  layer: () => layer4,
+  node: () => node5
+});
+import { Event } from "@opencode/schema/config";
+import { Cause, Effect, Layer, Queue, Stream } from "effect";
+import path from "path";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Npm } from "@opencode/util/npm";
+var resolve = Effect.fn("PluginSupervisor.resolve")(function* (modules, pre, post, operations, install, running) {
+  const matches = (selector, target) => selector === "*" || (selector.endsWith(".*") ? target.startsWith(selector.slice(0, -1)) : selector === target);
+  const definitions = [...pre, ...post];
+  const enabled = new Set(definitions.map((plugin) => plugin.id));
+  const packages = new Map;
+  const pending = new Set;
+  const failures = new Map;
+  const plugins = () => [...definitions, ...packages.values()];
+  for (const operation of operations) {
+    if (operation.type === "remove") {
+      if (operation.target === "*")
+        failures.clear();
+      plugins().filter((plugin) => matches(operation.target, plugin.id)).forEach((plugin) => enabled.delete(plugin.id));
+      continue;
+    }
+    const matched = plugins().filter((plugin) => matches(operation.target, plugin.id));
+    const selectsPlugins = matched.length > 0 || operation.target === "*" || operation.target.endsWith(".*") || operation.target.startsWith("opencode.");
+    if (selectsPlugins) {
+      matched.forEach((plugin) => enabled.add(plugin.id));
+      continue;
+    }
+    const plugin = yield* modules.load(operation, { install }).pipe(Effect.catchCause((cause) => {
+      const ref = `err_${crypto.randomUUID().slice(0, 8)}`;
+      const error = Cause.squash(cause);
+      return Effect.logWarning("failed to load plugin", { target: operation.target, ref, cause }).pipe(Effect.as({ error: error instanceof LoadError2 ? error.message : "Plugin failed to load", ref }));
+    }));
+    if ("pending" in plugin) {
+      pending.add(operation.target);
+      continue;
+    }
+    if ("error" in plugin) {
+      failures.set(operation.target, {
+        source: pluginSource(operation.target),
+        state: { status: "failed", error: plugin.error, ref: plugin.ref },
+        features: { server: true }
+      });
+      const retained = packages.get(operation.target) ?? running.get(operation.target);
+      if (!retained)
+        continue;
+      packages.set(operation.target, retained);
+      enabled.add(retained.id);
+      continue;
+    }
+    failures.delete(operation.target);
+    const previous = packages.get(operation.target);
+    if (previous)
+      enabled.delete(previous.id);
+    packages.set(operation.target, plugin);
+    enabled.add(plugin.id);
+  }
+  const ordered = [
+    ...pre.filter((plugin) => enabled.has(plugin.id)),
+    ...[...packages.values()].filter((plugin) => enabled.has(plugin.id)),
+    ...post.filter((plugin) => enabled.has(plugin.id))
+  ];
+  const duplicate = (plugin, index) => ordered.findIndex((other) => other.id === plugin.id) !== index;
+  return {
+    plugins: ordered.filter((plugin, index) => !duplicate(plugin, index)),
+    packages: new Map([...packages].filter(([, plugin]) => enabled.has(plugin.id))),
+    failures: [
+      ...failures.values(),
+      ...ordered.filter(duplicate).map((plugin) => ({
+        id: ID3.make(plugin.id),
+        source: plugin.source ?? { type: "builtin" },
+        state: { status: "failed", error: `Duplicate plugin ID: ${plugin.id}` },
+        features: { server: true, ...plugin.features }
+      }))
+    ],
+    pending: [...pending]
+  };
+});
+var layer4 = Layer.effectDiscard(Effect.gen(function* () {
+  const registry = yield* Service27;
+  const sdk = yield* Service6;
+  const instance = yield* Service5;
+  const sources = yield* Service3;
+  const modules = yield* make4();
+  const bus = yield* Service79;
+  const updates = yield* Service4;
+  const internal = yield* list2();
+  let release = yield* registry.hold();
+  yield* Effect.addFinalizer(() => release ?? Effect.void);
+  yield* Effect.addFinalizer(registry.close);
+  let packages = new Set;
+  let running = new Map;
+  let outdated = new Set;
+  const updating = new Set;
+  let generation = 0;
+  let observed = 0;
+  const activate = Effect.fn("PluginSupervisor.activate")(function* () {
+    const current = ++generation;
+    const pre = [
+      ...internal.pre.map((plugin) => ({ ...plugin, revision: "internal", source: { type: "builtin" } })),
+      ...sdk.all(),
+      ...instance.all()
+    ];
+    const post = internal.post.map((plugin) => ({
+      ...plugin,
+      revision: "internal",
+      source: { type: "builtin" }
+    }));
+    const operations = yield* sources.operations();
+    const immediate = yield* resolve(modules, pre, post, operations, false, running);
+    const source = (source) => source.type === "package" ? {
+      ...source,
+      ...outdated.has(source.target) ? { outdated: true } : {},
+      ...updating.has(source.target) ? { updating: true } : {}
+    } : source;
+    const apply = (resolved) => registry.activate(resolved.plugins.map((plugin) => plugin.source ? { ...plugin, source: source(plugin.source) } : plugin), resolved.failures.map((failure) => ({ ...failure, source: source(failure.source) })));
+    yield* apply(immediate);
+    const resolved = immediate.pending.length ? yield* resolve(modules, pre, post, operations, true, running) : immediate;
+    if (resolved !== immediate)
+      yield* apply(resolved);
+    running = resolved.packages;
+    const targets = new Set([...resolved.plugins, ...resolved.failures].flatMap((plugin) => plugin.source?.type === "package" ? [plugin.source.target] : []));
+    packages = targets;
+    yield* Effect.forEach(targets, (target) => updates.check(target).pipe(Effect.map((available) => [target, available])), { concurrency: "unbounded" }).pipe(Effect.flatMap((checked) => {
+      if (current !== generation)
+        return Effect.void;
+      const next = new Set(checked.flatMap(([target, available]) => available ? [target] : []));
+      if (next.size === outdated.size && [...next].every((target) => outdated.has(target)))
+        return Effect.void;
+      outdated = next;
+      return apply(resolved);
+    }), Effect.forkScoped({ startImmediately: true }));
+  });
+  const triggers = yield* Queue.sliding(1);
+  const notify = Effect.gen(function* () {
+    observed++;
+    if (!release)
+      release = yield* registry.hold();
+    yield* Queue.offer(triggers, observed);
+  });
+  const watch = (stream) => stream.pipe(Stream.runForEach(() => notify), Effect.forkScoped({ startImmediately: true }));
+  yield* watch(sources.changes());
+  yield* watch(modules.changes());
+  yield* watch(Stream.fromEffectRepeat(Effect.sleep("24 hours")));
+  yield* watch(bus.subscribe([Event.Updated, Updated2]));
+  yield* watch(updates.changes().pipe(Stream.filter((update) => packages.has(update.target)), Stream.tap((update) => Effect.sync(() => {
+    update.outdated ? outdated.add(update.target) : outdated.delete(update.target);
+    update.updating ? updating.add(update.target) : updating.delete(update.target);
+  }))));
+  yield* Stream.concat(Stream.succeed(0), Stream.fromQueue(triggers).pipe(Stream.debounce("100 millis"))).pipe(Stream.runForEach((target) => Effect.gen(function* () {
+    yield* activate().pipe(Effect.catchCause((cause) => Effect.logError("failed to reload plugins", { cause })));
+    if (observed !== target)
+      return;
+    const settled = release;
+    release = undefined;
+    if (settled)
+      yield* settled;
+  })), Effect.forkScoped({ startImmediately: true }));
+}));
+var nodeDeps = [
+  node22,
+  node9,
+  node8,
+  node6,
+  node7,
+  node84,
+  Npm.node,
+  node40,
+  requirements2
+];
+function pluginSource(target) {
+  if (path.isAbsolute(target))
+    return { type: "local", path: target };
+  return { type: "package", target };
+}
+var node5 = makeLocationNode({ name: "plugin-supervisor", layer: layer4, deps: nodeDeps });
+
+export { layer4, node5, exports_supervisor };

package/dist/chunks/aisdk-native-4knz6hnm.js

@@ -0,0 +1,22 @@
+// src/database/migration/20260808023530_workspace_domain.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260808023530_workspace_domain",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP TABLE \`workspace\`;`);
+      yield* tx.run(`
+        CREATE TABLE \`workspace\` (
+          \`id\` text PRIMARY KEY,
+          \`provider\` text NOT NULL,
+          \`binding\` text NOT NULL,
+          \`created_at\` integer NOT NULL,
+          \`last_used_at\` integer NOT NULL
+        );
+      `);
+    });
+  }
+};
+var _20260808023530_workspace_domain_default = migration;
+
+export { _20260808023530_workspace_domain_default };

package/dist/chunks/aisdk-native-4ns3h2re.js

@@ -0,0 +1,49 @@
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/workspace/driver.ts
+var exports_driver = {};
+__export(exports_driver, {
+  Binding: () => Binding2,
+  Error: () => Error5,
+  ProviderNotFound: () => ProviderNotFound2,
+  RegistryService: () => RegistryService2,
+  WorkspaceDriver: () => exports_driver,
+  make: () => make21,
+  node: () => node77,
+  registry: () => registry2,
+  registryNode: () => registryNode2
+});
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+var Binding2 = Schema.Record(Schema.String, Schema.Json);
+
+class Error5 extends Schema.TaggedError()("WorkspaceDriver.Error", {
+  message: Schema.optional(Schema.String),
+  cause: Schema.optional(Schema.Defect())
+}) {
+}
+
+class ProviderNotFound2 extends Schema.TaggedError()("WorkspaceDriver.ProviderNotFound", {
+  provider: Schema.String
+}) {
+}
+var make21 = (driver) => driver;
+
+class RegistryService2 extends Context.Service()("@opencode/WorkspaceDriverRegistry") {
+}
+var registry2 = (drivers) => ({
+  get: (provider) => {
+    const driver = Object.hasOwn(drivers, provider) ? drivers[provider] : undefined;
+    return driver ? Effect.succeed(driver) : Effect.fail(new ProviderNotFound2({ provider }));
+  }
+});
+var registryNode2 = (drivers) => makeGlobalNode({
+  service: RegistryService2,
+  layer: Layer.succeed(RegistryService2, RegistryService2.of(registry2(drivers))),
+  deps: []
+});
+var node77 = registryNode2({});
+
+export { Binding2, Error5, ProviderNotFound2, make21, RegistryService2, registry2, registryNode2, node77, exports_driver };