@opencode-ai/core 0.0.0-dev-19087 → 0.0.0-dev-19093

package/dist/chunks/{instance-qg2k024k.js → kv-fqf57vhm.js}

@@ -1,40 +1,45 @@
 import {
-  exports_integration
-} from "./instance-v6xa4kfs.js";
+  mergeOverlay2,
+  mergeHeaders2,
+  Info31
+} from "./kv-64z8z5x5.js";
 import {
-  exports_model
-} from "./instance-8manx9kj.js";
+  Info29
+} from "./kv-azv14p53.js";
 import {
-  exports_provider
-} from "./instance-68yag814.js";
+  Service79,
+  node83
+} from "./kv-9j3fyze8.js";
 import {
-  exports_state
-} from "./instance-j6s3yjyb.js";
+  create3
+} from "./kv-kg06axw8.js";
 import {
-  exports_bus
-} from "./instance-3dwd52hd.js";
+  ID14,
+  Service76,
+  node80
+} from "./kv-hbtmpj90.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/catalog.ts
-var exports_catalog = {};
-__export(exports_catalog, {
-  Catalog: () => exports_catalog,
-  Event: () => Event,
-  Service: () => Service,
-  node: () => node
+var exports_catalog2 = {};
+__export(exports_catalog2, {
+  Catalog: () => exports_catalog2,
+  Event: () => Event17,
+  Service: () => Service75,
+  node: () => node79
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Array, Context, Effect, Layer, Order, pipe } from "effect";
 import { Catalog } from "@opencode-ai/schema/catalog";
-import { Event } from "@opencode-ai/schema/catalog";
+import { Event as Event17 } from "@opencode-ai/schema/catalog";
 
-class Service extends Context.Service()("@opencode/Catalog") {
+class Service75 extends Context.Service()("@opencode/Catalog") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const bus = yield* exports_bus.Service;
-  const integrations = yield* exports_integration.Service;
+var layer = Layer.effect(Service75, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const integrations = yield* Service76;
   const available = (provider, integration) => {
     if (provider.activation === "disabled")
       return false;
@@ -49,16 +54,16 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       ...model,
       ...provider.canonical === undefined ? {} : { canonical: provider.canonical },
       package: model.package ?? provider.package,
-      settings: exports_provider.mergeOverlay(provider.settings, model.settings),
-      headers: exports_provider.mergeHeaders(provider.headers, model.headers),
-      body: exports_provider.mergeOverlay(provider.body, model.body)
+      settings: mergeOverlay2(provider.settings, model.settings),
+      headers: mergeHeaders2(provider.headers, model.headers),
+      body: mergeOverlay2(provider.body, model.body)
     };
   };
-  const state = exports_state.create({
+  const state = create3({
     name: "catalog",
     initial: () => ({ providers: new Map }),
     editor: (editor) => {
-      const result2 = {
+      const result = {
         provider: {
           list: () => Array.fromIterable(editor.providers.values()),
           get: (providerID) => editor.providers.get(providerID),
@@ -66,7 +71,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
             let current = editor.providers.get(providerID);
             if (!current) {
               current = {
-                provider: exports_provider.Info.empty(providerID),
+                provider: Info31.empty(providerID),
                 models: new Map
               };
               editor.providers.set(providerID, current);
@@ -84,12 +89,12 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
             let record = editor.providers.get(providerID);
             if (!record) {
               record = {
-                provider: exports_provider.Info.empty(providerID),
+                provider: Info31.empty(providerID),
                 models: new Map
               };
               editor.providers.set(providerID, record);
             }
-            const model = record.models.get(modelID) ?? exports_model.Info.default(providerID, modelID);
+            const model = record.models.get(modelID) ?? Info29.default(providerID, modelID);
             if (!record.models.has(modelID))
               record.models.set(modelID, model);
             fn(model);
@@ -107,7 +112,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           }
         }
       };
-      return result2;
+      return result;
     },
     notify: () => bus.publish(Catalog.Event.Updated, {}).pipe(Effect.asVoid, Effect.withSpan("Catalog.notify"))
   });
@@ -123,7 +128,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       }),
       available: Effect.fn("Catalog.provider.available")(function* () {
         const active = new Map((yield* integrations.list()).map((integration) => [integration.id, integration]));
-        return (yield* result.provider.all()).filter((provider) => available(provider, active.get(provider.integrationID ?? exports_integration.ID.make(provider.id))));
+        return (yield* result.provider.all()).filter((provider) => available(provider, active.get(provider.integrationID ?? ID14.make(provider.id))));
       })
     },
     model: {
@@ -178,9 +183,9 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       })
     }
   };
-  return Service.of(result);
+  return Service75.of(result);
 }));
 var SMALL_MODEL_FAMILY_PRIORITY = ["gpt-luna", "gemini-flash-lite", "gemini-flash", "claude-haiku"];
-var node = makeLocationNode({ service: Service, layer, deps: [exports_bus.node, exports_integration.node] });
+var node79 = makeLocationNode({ service: Service75, layer, deps: [node83, node80] });
 
-export { Service, node, exports_catalog, Event };
+export { Service75, node79, exports_catalog2, Event17 };

package/dist/chunks/{instance-qz5gwjr7.js → kv-fw8cvjkv.js}

@@ -1,25 +1,25 @@
 import {
-  AbsolutePath,
-  RelativePath
-} from "./instance-j07kk359.js";
+  AbsolutePath2,
+  RelativePath2
+} from "./kv-p8qxwesx.js";
 import {
-  exports_keyed_mutex
-} from "./instance-66mds5ht.js";
+  makeUnsafe2
+} from "./kv-jwcy2c2z.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/git.ts
-var exports_git = {};
-__export(exports_git, {
-  Git: () => exports_git,
-  OperationError: () => OperationError,
-  Repository: () => Repository,
-  Service: () => Service,
-  TreeID: () => TreeID,
-  Worktree: () => Worktree,
-  WorktreeError: () => WorktreeError,
-  node: () => node
+var exports_git3 = {};
+__export(exports_git3, {
+  Git: () => exports_git3,
+  OperationError: () => OperationError2,
+  Repository: () => Repository2,
+  Service: () => Service72,
+  TreeID: () => TreeID2,
+  Worktree: () => Worktree2,
+  WorktreeError: () => WorktreeError2,
+  node: () => node76
 });
 import path from "path";
 import { Context, Effect, Layer, Schema } from "effect";
@@ -27,10 +27,10 @@ import { ChildProcess } from "effect/unstable/process";
 import { FSUtil } from "@opencode-ai/util/fs-util";
 import { AppProcess } from "@opencode-ai/util/process";
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
-class Repository extends Schema.Class("Git.Repository")({
-  worktree: AbsolutePath,
-  gitDirectory: AbsolutePath,
-  commonDirectory: AbsolutePath
+class Repository2 extends Schema.Class("Git.Repository")({
+  worktree: AbsolutePath2,
+  gitDirectory: AbsolutePath2,
+  commonDirectory: AbsolutePath2
 }) {
 }
 var snapshotConfigFile = "opencode.gitconfig";
@@ -49,9 +49,9 @@ var snapshotConfig = `[core]
 	version = 4
 	threads = true
 `;
-var TreeID = Schema.String.pipe(Schema.brand("Git.TreeID"));
+var TreeID2 = Schema.String.pipe(Schema.brand("Git.TreeID"));
 
-class OperationError extends Schema.TaggedError()("Git.OperationError", {
+class OperationError2 extends Schema.TaggedError()("Git.OperationError", {
   operation: Schema.Literals([
     "clone",
     "fetch",
@@ -65,32 +65,32 @@ class OperationError extends Schema.TaggedError()("Git.OperationError", {
     "restore"
   ]),
   message: Schema.String,
-  directory: Schema.optional(AbsolutePath),
+  directory: Schema.optional(AbsolutePath2),
   cause: Schema.optional(Schema.Defect())
 }) {
 }
 
-class Worktree extends Schema.Class("Git.Worktree")({
-  directory: AbsolutePath,
+class Worktree2 extends Schema.Class("Git.Worktree")({
+  directory: AbsolutePath2,
   kind: Schema.Literals(["main", "linked"])
 }) {
 }
 
-class WorktreeError extends Schema.TaggedError()("Git.WorktreeError", {
+class WorktreeError2 extends Schema.TaggedError()("Git.WorktreeError", {
   operation: Schema.Literals(["create", "remove", "list"]),
   message: Schema.String,
-  directory: Schema.optional(AbsolutePath),
+  directory: Schema.optional(AbsolutePath2),
   forceRequired: Schema.optional(Schema.Boolean),
   cause: Schema.optional(Schema.Defect())
 }) {
 }
 
-class Service extends Context.Service()("@opencode/Git") {
+class Service72 extends Context.Service()("@opencode/Git") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service72, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
   const proc = yield* AppProcess.Service;
-  const locks = exports_keyed_mutex.makeUnsafe();
+  const locks = makeUnsafe2();
   const locked = (repository, effect) => locks.withLock(repository.gitDirectory)(effect);
   const discover = Effect.fn("Git.repo.discover")(function* (input) {
     const dotgit = yield* fs.up({ targets: [".git"], start: input, mode: "first" }).pipe(Effect.map((matches) => matches[0]), Effect.orElseSucceed(() => {
@@ -103,10 +103,10 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const [gitDir, commonDir, topLevel] = result.text.split(/\r?\n/);
     if (!gitDir || !commonDir)
       return;
-    return new Repository({
-      worktree: AbsolutePath.make(topLevel ? resolvePath(cwd, topLevel) : cwd),
-      gitDirectory: AbsolutePath.make(resolvePath(cwd, gitDir)),
-      commonDirectory: AbsolutePath.make(resolvePath(cwd, commonDir))
+    return new Repository2({
+      worktree: AbsolutePath2.make(topLevel ? resolvePath(cwd, topLevel) : cwd),
+      gitDirectory: AbsolutePath2.make(resolvePath(cwd, gitDir)),
+      commonDirectory: AbsolutePath2.make(resolvePath(cwd, commonDir))
     });
   });
   const remote = Effect.fn("Git.remote.get")(function* (repository, name = "origin") {
@@ -140,18 +140,18 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       return;
     return result.text.trim().replace(new RegExp(`^refs/remotes/${remoteName}/`), "") || undefined;
   });
-  const operation = Effect.fnUntraced(function* (operation2, directory, args) {
-    const result = yield* execute(directory, proc, args).pipe(Effect.mapError((cause) => new OperationError({ operation: operation2, directory, message: cause.message, cause })));
+  const operation = Effect.fnUntraced(function* (operation, directory, args) {
+    const result = yield* execute(directory, proc, args).pipe(Effect.mapError((cause) => new OperationError2({ operation, directory, message: cause.message, cause })));
     if (result.exitCode === 0)
       return;
-    return yield* new OperationError({
-      operation: operation2,
+    return yield* new OperationError2({
+      operation,
       directory,
-      message: result.stderr.trim() || result.text.trim() || `Git ${operation2} failed`
+      message: result.stderr.trim() || result.text.trim() || `Git ${operation} failed`
     });
   });
   const clone = Effect.fn("Git.repo.clone")(function* (input) {
-    yield* operation("clone", AbsolutePath.make(path.dirname(input.directory)), [
+    yield* operation("clone", AbsolutePath2.make(path.dirname(input.directory)), [
       "clone",
       "--depth",
       String(input.depth ?? 100),
@@ -163,7 +163,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const repository = yield* discover(input.directory);
     if (repository)
       return repository;
-    return yield* new OperationError({
+    return yield* new OperationError2({
       operation: "clone",
       directory: input.directory,
       message: "Cloned repository could not be opened"
@@ -199,7 +199,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       cwd: repository.worktree,
       env: options?.env,
       extendEnv: true
-    }), { stdin: options?.stdin }).pipe(Effect.mapError((cause) => new OperationError({
+    }), { stdin: options?.stdin }).pipe(Effect.mapError((cause) => new OperationError2({
       operation: operationName,
       directory: repository.worktree,
       message: cause.message,
@@ -208,16 +208,16 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const text = result.stdout.toString("utf8");
     if (result.exitCode === 0)
       return { text, stderr: result.stderr.toString("utf8") };
-    return yield* new OperationError({
+    return yield* new OperationError2({
       operation: operationName,
       directory: repository.worktree,
       message: result.stderr.toString("utf8").trim() || text.trim() || `Git ${operationName} failed`
     });
   });
   const create = Effect.fn("Git.repo.create")(function* (input) {
-    const operationError = (message) => (cause) => new OperationError({ operation: "create", directory: input.gitDirectory, message, cause });
+    const operationError = (message) => (cause) => new OperationError2({ operation: "create", directory: input.gitDirectory, message, cause });
     yield* fs.ensureDir(input.gitDirectory).pipe(Effect.mapError(operationError("Failed to create Git storage")));
-    const repository = new Repository({
+    const repository = new Repository2({
       worktree: input.worktree,
       gitDirectory: input.gitDirectory,
       commonDirectory: input.gitDirectory
@@ -251,13 +251,13 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       list(["diff-files", "--name-only", "-z", "--", input.scope]),
       list(["ls-files", "--others", "--exclude-standard", "-z", "--", input.scope])
     ], { concurrency: 2 });
-    const candidates = Array.from(new Set([...tracked, ...untracked])).map((file) => RelativePath.make(file));
+    const candidates = Array.from(new Set([...tracked, ...untracked])).map((file) => RelativePath2.make(file));
     if (!candidates.length)
       return { skipped: [] };
     const excluded = input.ignores ? yield* ignored({ repository: input.ignores, paths: candidates }) : new Set;
     const allowed = candidates.filter((item) => !excluded.has(item));
     const maximum = input.maximumUntrackedFileBytes;
-    const skipped = maximum ? (yield* Effect.forEach(untracked.filter((item) => allowed.includes(RelativePath.make(item))), (item) => fs.stat(path.join(input.repository.worktree, item)).pipe(Effect.map((info) => info.type === "File" && Number(info.size) > maximum ? RelativePath.make(item) : undefined), Effect.orElseSucceed(() => {
+    const skipped = maximum ? (yield* Effect.forEach(untracked.filter((item) => allowed.includes(RelativePath2.make(item))), (item) => fs.stat(path.join(input.repository.worktree, item)).pipe(Effect.map((info) => info.type === "File" && Number(info.size) > maximum ? RelativePath2.make(item) : undefined), Effect.orElseSucceed(() => {
       return;
     })), { concurrency: 8 })).filter((item) => item !== undefined) : [];
     const stage = allowed.filter((item) => !skipped.includes(item));
@@ -274,22 +274,22 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const result = yield* proc.run(ChildProcess.make("git", repositoryArgs(input.repository, ["check-ignore", "--no-index", "--stdin", "-z"]), {
       cwd: input.repository.worktree,
       extendEnv: true
-    }), { stdin: input.paths.join("\x00") + "\x00" }).pipe(Effect.mapError((cause) => new OperationError({
+    }), { stdin: input.paths.join("\x00") + "\x00" }).pipe(Effect.mapError((cause) => new OperationError2({
       operation: "list_files",
       directory: input.repository.worktree,
       message: cause.message,
       cause
     })));
     if (result.exitCode !== 0 && result.exitCode !== 1)
-      return yield* new OperationError({
+      return yield* new OperationError2({
         operation: "list_files",
         directory: input.repository.worktree,
         message: result.stderr.toString("utf8").trim() || "Failed to check ignored paths"
       });
-    return new Set(result.stdout.toString("utf8").split("\x00").filter(Boolean).map((file) => RelativePath.make(file)));
+    return new Set(result.stdout.toString("utf8").split("\x00").filter(Boolean).map((file) => RelativePath2.make(file)));
   });
   const writeTree = Effect.fn("Git.tree.write")(function* (repository) {
-    return TreeID.make((yield* repositoryOperation("write_tree", repository, ["write-tree"])).text.trim());
+    return TreeID2.make((yield* repositoryOperation("write_tree", repository, ["write-tree"])).text.trim());
   });
   const captureTree = Effect.fn("Git.tree.capture")((input) => locked(input.repository, Effect.gen(function* () {
     yield* Effect.forEach(input.scopes, (scope) => refresh({ ...input, scope }), { discard: true });
@@ -303,7 +303,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       "-z",
       input.from,
       input.to
-    ])).text.split("\x00").filter(Boolean).map((file) => RelativePath.make(file));
+    ])).text.split("\x00").filter(Boolean).map((file) => RelativePath2.make(file));
   });
   const treeDiff = Effect.fn("Git.tree.diff")(function* (input) {
     const paths = input.paths ?? (yield* treeFiles(input));
@@ -357,7 +357,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     if (!text)
       return false;
     if (!/^\d+\s+\w+\s+[0-9a-f]+\t/.test(text))
-      return yield* new OperationError({
+      return yield* new OperationError2({
         operation: "restore",
         directory: repository.worktree,
         message: `Invalid tree entry for ${file}`
@@ -369,23 +369,23 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       yield* repositoryOperation("restore", input.repository, ["checkout", tree, "--", file]);
       return;
     }
-    yield* fs.remove(path.join(input.repository.worktree, file), { recursive: true, force: true }).pipe(Effect.mapError((cause) => new OperationError({
+    yield* fs.remove(path.join(input.repository.worktree, file), { recursive: true, force: true }).pipe(Effect.mapError((cause) => new OperationError2({
       operation: "restore",
       directory: input.repository.worktree,
       message: `Failed to remove ${file}`,
       cause
     })));
   }), { discard: true })));
-  const worktreeRun = Effect.fnUntraced(function* (operation2, repository, args, worktreeDirectory, cwd = repository.worktree) {
-    const result = yield* proc.run(ChildProcess.make("git", args, { cwd, extendEnv: true, stdin: "ignore" })).pipe(Effect.mapError((cause) => new WorktreeError({ operation: operation2, directory: worktreeDirectory, message: cause.message, cause })));
+  const worktreeRun = Effect.fnUntraced(function* (operation, repository, args, worktreeDirectory, cwd = repository.worktree) {
+    const result = yield* proc.run(ChildProcess.make("git", args, { cwd, extendEnv: true, stdin: "ignore" })).pipe(Effect.mapError((cause) => new WorktreeError2({ operation, directory: worktreeDirectory, message: cause.message, cause })));
     if (result.exitCode === 0)
       return result.stdout.toString("utf8");
     const message = result.stderr.toString("utf8").trim() || result.stdout.toString("utf8").trim() || "Git failed";
-    return yield* new WorktreeError({
-      operation: operation2,
+    return yield* new WorktreeError2({
+      operation,
       directory: worktreeDirectory,
       message,
-      forceRequired: operation2 === "remove" && /contains modified or untracked files|is dirty/i.test(message)
+      forceRequired: operation === "remove" && /contains modified or untracked files|is dirty/i.test(message)
     });
   });
   const worktreeCreate = Effect.fn("Git.worktree.create")(function* (input) {
@@ -393,7 +393,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const repository = yield* discover(input.directory);
     if (repository)
       return repository;
-    return yield* new WorktreeError({
+    return yield* new WorktreeError2({
       operation: "create",
       directory: input.directory,
       message: "Created worktree could not be opened"
@@ -404,12 +404,12 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   });
   const worktreeList = Effect.fn("Git.worktree.list")(function* (repository) {
     return (yield* worktreeRun("list", repository, ["worktree", "list", "--porcelain"])).split(`
-`).filter((line) => line.startsWith("worktree ")).map((line, index) => new Worktree({
-      directory: AbsolutePath.make(resolvePath(repository.worktree, line.slice("worktree ".length).trim())),
+`).filter((line) => line.startsWith("worktree ")).map((line, index) => new Worktree2({
+      directory: AbsolutePath2.make(resolvePath(repository.worktree, line.slice("worktree ".length).trim())),
       kind: index === 0 ? "main" : "linked"
     }));
   });
-  return Service.of({
+  return Service72.of({
     repo: { discover, clone, create },
     remote: { get: remote },
     history: { head, branch, defaultRemoteBranch: remoteHead, rootCommits: roots },
@@ -425,7 +425,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     }
   });
 }));
-var node = makeGlobalNode({ service: Service, layer, deps: [FSUtil.node, AppProcess.node] });
+var node76 = makeGlobalNode({ service: Service72, layer, deps: [FSUtil.node, AppProcess.node] });
 function run(cwd, proc, args) {
   return execute(cwd, proc, args).pipe(Effect.orElseSucceed(() => ({ exitCode: 1, text: "", stderr: "" })));
 }
@@ -450,4 +450,4 @@ function resolvePath(cwd, value) {
   return path.resolve(cwd, normalized);
 }
 
-export { Repository, TreeID, OperationError, Worktree, WorktreeError, Service, node, exports_git };
+export { Repository2, TreeID2, OperationError2, Worktree2, WorktreeError2, Service72, node76, exports_git3 };

package/dist/chunks/{instance-5y5kqjze.js → kv-fxbjtjnd.js}

@@ -1,47 +1,47 @@
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/shell/result.ts
 var exports_result = {};
 __export(exports_result, {
   ShellResult: () => exports_result,
-  metadata: () => metadata,
-  notice: () => notice,
-  notification: () => notification,
-  output: () => output,
-  unavailable: () => unavailable,
-  userNotification: () => userNotification
+  metadata: () => metadata2,
+  notice: () => notice2,
+  notification: () => notification2,
+  output: () => output2,
+  unavailable: () => unavailable2,
+  userNotification: () => userNotification2
 });
 var missing = "Shell command output is no longer available.";
-var unavailable = {
+var unavailable2 = {
   output: missing,
   cursor: Buffer.byteLength(missing),
   size: Buffer.byteLength(missing),
   truncated: false
 };
-function output(result) {
+function output2(result) {
   return {
-    output: result.capture?.output ?? unavailable.output,
+    output: result.capture?.output ?? unavailable2.output,
     truncated: result.capture?.truncated ?? false,
     ...result.info.exit !== undefined ? { exit: result.info.exit } : {},
     ...result.info.status === "timeout" ? { timeout: true } : {}
   };
 }
-function notice(output2) {
-  if (output2.timeout)
+function notice2(output) {
+  if (output.timeout)
     return "Command timed out before completion.";
-  if (output2.exit !== undefined)
-    return `Command exited with code ${output2.exit}.`;
+  if (output.exit !== undefined)
+    return `Command exited with code ${output.exit}.`;
 }
-function metadata(output2) {
+function metadata2(output) {
   return {
-    truncated: output2.truncated,
-    ...output2.exit !== undefined ? { exit: output2.exit } : {},
-    ...output2.timeout !== undefined ? { timeout: output2.timeout } : {}
+    truncated: output.truncated,
+    ...output.exit !== undefined ? { exit: output.exit } : {},
+    ...output.timeout !== undefined ? { timeout: output.timeout } : {}
   };
 }
-function notification(input) {
+function notification2(input) {
   return {
     text: `<shell id="${input.jobID ?? input.shellID}" state="${input.state}" command="${input.command}">
 ${input.text}
@@ -51,14 +51,14 @@ ${input.text}
       shellID: input.shellID,
       ...input.jobID !== undefined ? { jobID: input.jobID } : {},
       state: input.state,
-      ...input.output ? metadata(input.output) : {}
+      ...input.output ? metadata2(input.output) : {}
     }
   };
 }
-function userNotification(result) {
-  const captured = output(result);
-  const status = result.info.status === "killed" ? "Command cancelled." : notice(captured) ?? "Command exited with code unknown.";
-  const message = notification({
+function userNotification2(result) {
+  const captured = output2(result);
+  const status = result.info.status === "killed" ? "Command cancelled." : notice2(captured) ?? "Command exited with code unknown.";
+  const message = notification2({
     shellID: result.info.id,
     command: result.info.command,
     state: result.info.status === "killed" ? "cancelled" : "completed",
@@ -71,4 +71,4 @@ ${status}`,
 ${message.text}` };
 }
 
-export { unavailable, output, notice, metadata, notification, userNotification, exports_result };
+export { unavailable2, output2, notice2, metadata2, notification2, userNotification2, exports_result };

package/dist/chunks/{instance-brsh5f65.js → kv-fxgpk5d8.js}

@@ -6,7 +6,7 @@ import { convertToBase64 } from "@ai-sdk/provider-utils";
 function getOpenAIMetadata(message) {
   return message?.providerOptions?.copilot ?? {};
 }
-function convertToOpenAICompatibleChatMessages(prompt) {
+function convertToOpenAICompatibleChatMessages2(prompt) {
   const messages = [];
   for (const { role, content, ...message } of prompt) {
     const metadata = getOpenAIMetadata({ ...message });
@@ -143,4 +143,4 @@ function convertToOpenAICompatibleChatMessages(prompt) {
   return messages;
 }
 
-export { convertToOpenAICompatibleChatMessages };
+export { convertToOpenAICompatibleChatMessages2 };

package/dist/chunks/{instance-dexm22yg.js → kv-fxypknc8.js}

@@ -1,22 +1,22 @@
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/database/sqlite.ts
 var exports_sqlite = {};
 __export(exports_sqlite, {
-  Native: () => Native,
+  Native: () => Native2,
   Sqlite: () => exports_sqlite,
-  makeClient: () => makeClient,
-  makeConnection: () => makeConnection
+  makeClient: () => makeClient2,
+  makeConnection: () => makeConnection2
 });
 import { Context, Effect, Fiber, Scope, Semaphore, Stream } from "effect";
 import { identity } from "effect/Function";
 import { SqlClient, Statement } from "effect/unstable/sql";
 
-class Native extends Context.Service()("@opencode-ai/core/database/SqliteNative") {
+class Native2 extends Context.Service()("@opencode-ai/core/database/SqliteNative") {
 }
-var makeConnection = (run, runValues, extensions) => identity({
+var makeConnection2 = (run, runValues, extensions) => identity({
   execute(query, params, transformRows) {
     return transformRows ? Effect.map(run(query, params), transformRows) : run(query, params);
   },
@@ -37,7 +37,7 @@ var makeConnection = (run, runValues, extensions) => identity({
   },
   ...extensions
 });
-var makeClient = (options, connection, typeId, extensions) => Effect.gen(function* () {
+var makeClient2 = (options, connection, typeId, extensions) => Effect.gen(function* () {
   const semaphore = yield* Semaphore.make(1);
   const acquirer = semaphore.withPermits(1)(Effect.succeed(connection));
   const transactionAcquirer = Effect.uninterruptibleMask((restore) => {
@@ -62,4 +62,4 @@ var makeClient = (options, connection, typeId, extensions) => Effect.gen(functio
   });
 });
 
-export { Native, makeConnection, makeClient, exports_sqlite };
+export { Native2, makeConnection2, makeClient2, exports_sqlite };