@opencode-ai/core 0.0.0-dev-19092 → 0.0.0-dev-19094

package/dist/chunks/{integration-x4az4y7r.js → command-k4bwy1x5.js}

@@ -1,15 +1,15 @@
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/id/id.ts
 var exports_id = {};
 __export(exports_id, {
   Identifier: () => exports_id,
-  ascending: () => ascending,
+  ascending: () => ascending2,
   create: () => createID,
-  descending: () => descending,
-  timestamp: () => timestamp
+  descending: () => descending2,
+  timestamp: () => timestamp2
 });
 import { create } from "@opencode-ai/schema/identifier";
 var prefixes = {
@@ -24,10 +24,10 @@ var prefixes = {
   tool: "tool",
   workspace: "wrk"
 };
-function ascending(prefix, given) {
+function ascending2(prefix, given) {
   return generateID(prefix, "ascending", given);
 }
-function descending(prefix, given) {
+function descending2(prefix, given) {
   return generateID(prefix, "descending", given);
 }
 function generateID(prefix, direction, given) {
@@ -42,10 +42,10 @@ function generateID(prefix, direction, given) {
 function createID(prefix, direction, timestamp) {
   return prefix + "_" + create(direction === "descending", timestamp);
 }
-function timestamp(id) {
+function timestamp2(id) {
   const prefix = id.split("_")[0];
   const hex = id.slice(prefix.length + 1, prefix.length + 13);
   return Number(BigInt(`0x${hex}`) / 0x1000n);
 }
 
-export { ascending, descending, createID, timestamp, exports_id };
+export { ascending2, descending2, createID, timestamp2, exports_id };

package/dist/chunks/command-k5kpsmwm.js

@@ -0,0 +1,119 @@
+import {
+  Service80
+} from "./command-mh85gtv1.js";
+import {
+  Service79
+} from "./command-pdae5shs.js";
+import {
+  Service33
+} from "./command-y092mk2a.js";
+import {
+  RelativePath2
+} from "./command-p8qxwesx.js";
+import {
+  ID9,
+  Service49
+} from "./command-yzsm82be.js";
+import {
+  SessionEvent2
+} from "./command-mntxs535.js";
+import {
+  SessionMessage2
+} from "./command-982e01ww.js";
+import {
+  MessageNotFoundError2
+} from "./command-c28brx2k.js";
+import {
+  SessionMessageTable2
+} from "./command-hrvm11jt.js";
+import {
+  __export
+} from "./command-9rqn6x4v.js";
+
+// src/session/revert.ts
+var exports_revert = {};
+__export(exports_revert, {
+  MessageNotFoundError: () => MessageNotFoundError2,
+  SessionRevert: () => exports_revert,
+  clear: () => clear2,
+  commit: () => commit2,
+  stage: () => stage2
+});
+import { and, asc, eq, gt } from "drizzle-orm";
+import { Effect, Schema } from "effect";
+var stage2 = Effect.fn("SessionRevert.stage")(function* (input) {
+  const instances = yield* Service33;
+  const database = yield* Service80;
+  const bus = yield* Service79;
+  return yield* Effect.gen(function* () {
+    const snapshot = yield* Service49;
+    const original = input.session.revert?.snapshot ? ID9.make(input.session.revert.snapshot) : yield* snapshot.capture();
+    const next = yield* plan(database.db, { sessionID: input.session.id, messageID: input.messageID });
+    const restore = new Map;
+    if (original) {
+      for (const file of input.session.revert?.files ?? [])
+        restore.set(RelativePath2.make(file.file), original);
+    }
+    if (input.files !== false)
+      for (const [file, tree] of next)
+        restore.set(file, tree);
+    if (restore.size)
+      yield* snapshot.restore({ files: restore });
+    const paths = input.files === false ? [] : Array.from(next.keys());
+    const files = original ? yield* snapshot.diff({ from: original, to: (yield* snapshot.capture()) ?? original, paths }) : [];
+    const revert = {
+      messageID: input.messageID,
+      snapshot: original,
+      files
+    };
+    yield* bus.publish(SessionEvent2.RevertEvent.Staged, {
+      sessionID: input.session.id,
+      revert
+    });
+    return revert;
+  }).pipe(instances.provide(input.session));
+});
+var clear2 = Effect.fn("SessionRevert.clear")(function* (session) {
+  const instances = yield* Service33;
+  const bus = yield* Service79;
+  yield* Effect.gen(function* () {
+    const snapshot = yield* Service49;
+    if (!session.revert)
+      return;
+    const original = session.revert.snapshot ? ID9.make(session.revert.snapshot) : undefined;
+    if (original)
+      yield* snapshot.restore({
+        files: new Map((session.revert.files ?? []).map((file) => [RelativePath2.make(file.file), original]))
+      });
+    yield* bus.publish(SessionEvent2.RevertEvent.Cleared, {
+      sessionID: session.id
+    });
+  }).pipe(instances.provide(session));
+});
+var commit2 = Effect.fn("SessionRevert.commit")(function* (bus, session) {
+  if (!session.revert)
+    return;
+  yield* bus.publish(SessionEvent2.RevertEvent.Committed, {
+    sessionID: session.id,
+    to: session.revert.messageID
+  });
+});
+var plan = Effect.fn("SessionRevert.plan")(function* (db, input) {
+  const boundary = yield* db.select({ seq: SessionMessageTable2.seq }).from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, input.sessionID), eq(SessionMessageTable2.id, input.messageID))).get().pipe(Effect.orDie);
+  if (!boundary)
+    return yield* new MessageNotFoundError2(input);
+  const rows = yield* db.select().from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, input.sessionID), eq(SessionMessageTable2.type, "assistant"), gt(SessionMessageTable2.seq, boundary.seq))).orderBy(asc(SessionMessageTable2.seq)).all().pipe(Effect.orDie);
+  const decode = Schema.decodeUnknownEffect(SessionMessage2.Info);
+  const files = new Map;
+  for (const row of rows) {
+    const message = yield* decode({ ...row.data, id: row.id, type: row.type }).pipe(Effect.orDie);
+    if (message.type !== "assistant" || !message.snapshot?.start)
+      continue;
+    for (const file of message.snapshot.files ?? [])
+      if (!files.has(file))
+        files.set(file, ID9.make(message.snapshot.start));
+  }
+  return files;
+});
+
+export { stage2, clear2, commit2, exports_revert };

package/dist/chunks/{integration-42zyazrq.js → command-k8962brh.js}

@@ -1,15 +1,15 @@
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/v1/config/command.ts
-var exports_command = {};
-__export(exports_command, {
-  ConfigCommandV1: () => exports_command,
-  Info: () => Info
+var exports_command4 = {};
+__export(exports_command4, {
+  ConfigCommandV1: () => exports_command4,
+  Info: () => Info19
 });
 import { Schema } from "effect";
-var Info = Schema.Struct({
+var Info19 = Schema.Struct({
   template: Schema.String,
   description: Schema.optional(Schema.String),
   agent: Schema.optional(Schema.String),
@@ -18,4 +18,4 @@ var Info = Schema.Struct({
   subtask: Schema.optional(Schema.Boolean)
 });
 
-export { Info, exports_command };
+export { Info19, exports_command4 };

package/dist/chunks/{integration-hzwx8p6y.js → command-k8feg6vv.js}

@@ -1,12 +1,12 @@
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/session/system-prompt.ts
-var exports_system_prompt = {};
-__export(exports_system_prompt, {
-  SessionSystemPrompt: () => exports_system_prompt,
-  make: () => make
+var exports_system_prompt2 = {};
+__export(exports_system_prompt2, {
+  SessionSystemPrompt: () => exports_system_prompt2,
+  make: () => make13
 });
 
 // src/session/runner/prompt/system.txt
@@ -28,7 +28,7 @@ var system_default = `You are an AI agent powered by OpenCode, a coding agent ha
 `;
 
 // src/session/system-prompt.ts
-function make(tools) {
+function make13(tools) {
   const instructions = [];
   if (tools.includes("shell")) {
     instructions.push("- Prefer dedicated tools over shell commands; fall back to the shell when a tool cannot do what you need.");
@@ -43,4 +43,4 @@ function make(tools) {
 `));
 }
 
-export { make, exports_system_prompt };
+export { make13, exports_system_prompt2 };

package/dist/chunks/{integration-j6s3yjyb.js → command-kg06axw8.js}

@@ -1,17 +1,17 @@
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/state.ts
 var exports_state = {};
 __export(exports_state, {
   State: () => exports_state,
-  batch: () => batch,
-  create: () => create,
-  group: () => group,
-  inherit: () => inherit,
-  reconcile: () => reconcile,
-  shutdown: () => shutdown
+  batch: () => batch2,
+  create: () => create3,
+  group: () => group2,
+  inherit: () => inherit2,
+  reconcile: () => reconcile2,
+  shutdown: () => shutdown2
 });
 import { Cause, Context, Effect, Exit, Fiber, Scope } from "effect";
 var CurrentGroup = Context.Reference("@opencode/State/CurrentGroup", {
@@ -19,46 +19,46 @@ var CurrentGroup = Context.Reference("@opencode/State/CurrentGroup", {
     return;
   }
 });
-function group(report) {
-  const group2 = { failed: false, registrations: new Set, report };
-  return (effect) => Effect.provideService(effect, CurrentGroup, group2);
+function group2(report) {
+  const group = { failed: false, registrations: new Set, report };
+  return (effect) => Effect.provideService(effect, CurrentGroup, group);
 }
-function disable(group2, failure) {
-  if (group2.failed)
+function disable(group, failure) {
+  if (group.failed)
     return;
-  group2.failed = true;
+  group.failed = true;
   const notifications = new Set;
-  for (const registration of group2.registrations) {
+  for (const registration of group.registrations) {
     registration.remove();
     notifications.add(registration.notify);
   }
-  group2.report(failure, Effect.forEach(notifications, (notify) => notify, { discard: true }));
+  group.report(failure, Effect.forEach(notifications, (notify) => notify, { discard: true }));
 }
 var CurrentBatch = Context.Reference("@opencode/State/CurrentBatch", {
   defaultValue: () => {
     return;
   }
 });
-function batch(effect) {
+function batch2(effect) {
   return run(effect, false);
 }
-function shutdown(effect) {
+function shutdown2(effect) {
   return run(effect, true);
 }
-function run(effect, shutdown2) {
+function run(effect, shutdown) {
   return Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
     const current = yield* CurrentBatch;
-    if (current?.active && !shutdown2)
+    if (current?.active && !shutdown)
       return yield* restore(effect);
-    const batch2 = { active: true, shutdown: shutdown2, notifications: new Set };
-    const exit = yield* restore(effect.pipe(Effect.provideService(CurrentBatch, batch2))).pipe(Effect.exit);
-    batch2.active = false;
-    const notifications = yield* Effect.forEach(batch2.notifications, (notify) => restore(notify).pipe(Effect.exit));
+    const batch = { active: true, shutdown, notifications: new Set };
+    const exit = yield* restore(effect.pipe(Effect.provideService(CurrentBatch, batch))).pipe(Effect.exit);
+    batch.active = false;
+    const notifications = yield* Effect.forEach(batch.notifications, (notify) => restore(notify).pipe(Effect.exit));
     yield* Exit.asVoidAll([exit, ...notifications]);
     return yield* exit;
   }));
 }
-function reconcile(root, fork, work) {
+function reconcile2(root, fork, work) {
   return Effect.gen(function* () {
     const exit = yield* Fiber.await(fork(work()));
     if (Exit.isFailure(exit) && root.state._tag === "Closed" && Cause.hasInterruptsOnly(exit.cause))
@@ -66,11 +66,11 @@ function reconcile(root, fork, work) {
     yield* exit;
   });
 }
-var inherit = Effect.fnUntraced(function* () {
-  const batch2 = yield* CurrentBatch;
-  return (effect) => Effect.provideService(effect, CurrentBatch, batch2);
+var inherit2 = Effect.fnUntraced(function* () {
+  const batch = yield* CurrentBatch;
+  return (effect) => Effect.provideService(effect, CurrentBatch, batch);
 });
-function create(options) {
+function create3(options) {
   let state = options.initial();
   const transforms = new Set;
   let dirty = false;
@@ -116,13 +116,13 @@ function create(options) {
     if (closed)
       return;
     invalidate();
-    const batch2 = yield* CurrentBatch;
-    if (batch2?.active) {
-      if (batch2.shutdown) {
+    const batch = yield* CurrentBatch;
+    if (batch?.active) {
+      if (batch.shutdown) {
         closed = true;
         return;
       }
-      batch2.notifications.add(notify);
+      batch.notifications.add(notify);
       return;
     }
     yield* restore(notify);
@@ -132,16 +132,16 @@ function create(options) {
     transform: Effect.fn("State.transform")(function* (update) {
       yield* Effect.annotateCurrentSpan("state", options.name ?? "anonymous");
       const scope = yield* Scope.Scope;
-      const group2 = yield* CurrentGroup;
-      if (group2?.failed)
+      const group = yield* CurrentGroup;
+      if (group?.failed)
         return { dispose: Effect.void };
       return yield* Effect.uninterruptible(Effect.gen(function* () {
-        const transform = { run: update, group: group2 };
+        const transform = { run: update, group };
         const registration = {
           remove: () => {
             if (!transforms.delete(transform))
               return false;
-            group2?.registrations.delete(registration);
+            group?.registrations.delete(registration);
             invalidate();
             return true;
           },
@@ -149,7 +149,7 @@ function create(options) {
         };
         const dispose = Effect.uninterruptible(Effect.suspend(() => registration.remove() ? changed : Effect.void));
         transforms.add(transform);
-        group2?.registrations.add(registration);
+        group?.registrations.add(registration);
         yield* Scope.addFinalizer(scope, dispose);
         yield* changed;
         return { dispose };
@@ -159,4 +159,4 @@ function create(options) {
   };
 }
 
-export { group, batch, shutdown, reconcile, inherit, create, exports_state };
+export { group2, batch2, shutdown2, reconcile2, inherit2, create3, exports_state };

package/dist/chunks/{integration-8hhfhc9z.js → command-kj8q7mtc.js}

@@ -1,58 +1,61 @@
 import {
-  exports_tool
-} from "./integration-svrgfpe2.js";
+  definition2,
+  execute3,
+  normalizeContent2,
+  normalizedName2,
+  effectiveName2
+} from "./command-3t738kvx.js";
 import {
-  definition,
-  effectiveName,
-  execute,
-  normalizeContent,
-  normalizedName
-} from "./integration-xx9qfgev.js";
+  create2,
+  catalog2
+} from "./command-6tf8tr4v.js";
 import {
-  exports_image
-} from "./integration-b9dgxk92.js";
+  create3
+} from "./command-kg06axw8.js";
 import {
-  exports_wildcard
-} from "./integration-edxnhgvj.js";
+  Service76,
+  node79
+} from "./command-jc31v14r.js";
 import {
-  exports_hooks
-} from "./integration-xws7arpm.js";
+  Service46,
+  node48
+} from "./command-ekmzxrqe.js";
 import {
-  exports_state
-} from "./integration-j6s3yjyb.js";
+  match2
+} from "./command-y1fvbwt7.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/tool.ts
-var exports_tool2 = {};
-__export(exports_tool2, {
-  CallID: () => CallID,
-  Content: () => Content,
+var exports_tool = {};
+__export(exports_tool, {
+  CallID: () => CallID2,
+  Content: () => Content3,
   Error: () => Error2,
-  FileContent: () => FileContent,
-  RegistrationError: () => RegistrationError,
-  Service: () => Service,
-  TextContent: () => TextContent,
-  Tool: () => exports_tool2,
-  node: () => node
+  FileContent: () => FileContent3,
+  RegistrationError: () => RegistrationError2,
+  Service: () => Service37,
+  TextContent: () => TextContent2,
+  Tool: () => exports_tool,
+  node: () => node39
 });
-import { CallID, Content, Error as Error2, FileContent, TextContent } from "@opencode-ai/schema/tool";
+import { CallID as CallID2, Content as Content3, Error as Error2, FileContent as FileContent3, TextContent as TextContent2 } from "@opencode-ai/schema/tool";
 import { ToolDefinition } from "@opencode-ai/ai";
 import { Tool } from "@opencode-ai/schema/tool";
 import { Context, Effect, Layer, Result, Schema, SchemaIssue } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
-class RegistrationError extends Schema.TaggedError()("Tool.RegistrationError", {
+class RegistrationError2 extends Schema.TaggedError()("Tool.RegistrationError", {
   name: Schema.String,
   message: Schema.String
 }) {
 }
 
-class Service extends Context.Service()("@opencode/Tool") {
+class Service37 extends Context.Service()("@opencode/Tool") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const hooks = yield* exports_hooks.Service;
-  const image = yield* exports_image.Service;
+var layer = Layer.effect(Service37, Effect.gen(function* () {
+  const hooks = yield* Service46;
+  const image = yield* Service76;
   const normalizeImages = Effect.fnUntraced(function* (content) {
     const normalized = yield* Effect.forEach(content, (item) => {
       if (item.type !== "file" || !item.mime.startsWith("image/"))
@@ -88,7 +91,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     input
   });
   const executeTool = Effect.fn("Tool.execute")(function* (tool, name, input, context) {
-    const execution = yield* execute(tool, input, context).pipe(Effect.map((value) => ({ value })), Effect.catchTag("Tool.Error", (failure) => Effect.succeed({ failure })));
+    const execution = yield* execute3(tool, input, context).pipe(Effect.map((value) => ({ value })), Effect.catchTag("Tool.Error", (failure) => Effect.succeed({ failure })));
     const base = {
       tool: name,
       sessionID: context.sessionID,
@@ -98,13 +101,13 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       input
     };
     if ("failure" in execution) {
-      const afterEvent2 = {
+      const afterEvent = {
         ...base,
         status: "error",
         error: execution.failure
       };
-      yield* hooks.trigger("tool", "execute.after", afterEvent2);
-      return yield* afterEvent2.error;
+      yield* hooks.trigger("tool", "execute.after", afterEvent);
+      return yield* afterEvent.error;
     }
     const afterEvent = {
       ...base,
@@ -116,14 +119,14 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       }
     };
     yield* hooks.trigger("tool", "execute.after", afterEvent);
-    const afterContent = yield* normalizeImages(normalizeContent(afterEvent.result.content, afterEvent.result.output));
+    const afterContent = yield* normalizeImages(normalizeContent2(afterEvent.result.content, afterEvent.result.output));
     return {
       ...afterEvent.result.output === undefined ? {} : { output: afterEvent.result.output },
       content: afterContent,
       ...afterEvent.result.metadata === undefined ? {} : { metadata: afterEvent.result.metadata }
     };
   });
-  const state = exports_state.create({
+  const state = create3({
     name: "tool",
     initial: () => ({
       tools: new Map,
@@ -147,7 +150,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           editor.errors.push({ kind: "tool", name: tool.name, namespace: tool.options?.namespace, error });
           return;
         }
-        const id = effectiveName(tool);
+        const id = effectiveName2(tool);
         editor.tools.set(id, { ...tool, id, options: tool.options && { ...tool.options } });
       },
       update: (id, update) => {
@@ -177,7 +180,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       error: error.message
     }), { discard: true })
   });
-  return Service.of({
+  return Service37.of({
     transform: state.transform,
     reload: state.reload,
     snapshot: Effect.fn("Tool.snapshot")((permissions) => Effect.sync(() => {
@@ -193,13 +196,13 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       const namespaces = state.get().namespaces;
       const codeModeInventory = { tools: codeModeTools, namespaces };
       const codeModeEnabled = !whollyDisabled("execute", rules);
-      const codeModeTool = codeModeEnabled ? exports_tool.create(codeModeInventory, (name, tool, input, context) => beforeExecute(name, input, context).pipe(Effect.flatMap((event) => executeTool(tool, name, event.input, context)))) : undefined;
-      const codeModeCatalog = codeModeEnabled ? exports_tool.catalog(codeModeInventory) : undefined;
+      const codeModeTool = codeModeEnabled ? create2(codeModeInventory, (name, tool, input, context) => beforeExecute(name, input, context).pipe(Effect.flatMap((event) => executeTool(tool, name, event.input, context)))) : undefined;
+      const codeModeCatalog = codeModeEnabled ? catalog2(codeModeInventory) : undefined;
       return {
         ...codeModeCatalog === undefined ? {} : { codeModeCatalog },
         definitions: [
-          ...Array.from(direct).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, tool]) => definition(tool)),
-          ...codeModeTool ? [definition(codeModeTool)] : []
+          ...Array.from(direct).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, tool]) => definition2(tool)),
+          ...codeModeTool ? [definition2(codeModeTool)] : []
         ],
         execute: Effect.fnUntraced(function* (input) {
           const context = {
@@ -226,7 +229,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   });
 }));
 var whollyDisabled = (action, rules) => {
-  const rule = rules.findLast((rule2) => exports_wildcard.match(action, rule2.action));
+  const rule = rules.findLast((rule) => match2(action, rule.action));
   return rule?.resource === "*" && rule.effect === "deny";
 };
 var formatSchemaIssue = SchemaIssue.makeFormatterDefault();
@@ -242,27 +245,27 @@ function registrationError(tool) {
     if (error)
       return error;
   }
-  const name = normalizedName(tool);
+  const name = normalizedName2(tool);
   if (!/^[A-Za-z0-9_-]{1,64}$/.test(name))
-    return new RegistrationError({ name, message: `Invalid tool name: ${name}` });
-  const id = effectiveName(tool);
+    return new RegistrationError2({ name, message: `Invalid tool name: ${name}` });
+  const id = effectiveName2(tool);
   if (tool.options?.codemode === false && id === "execute")
-    return new RegistrationError({ name: id, message: 'Tool name "execute" is reserved for CodeMode' });
+    return new RegistrationError2({ name: id, message: 'Tool name "execute" is reserved for CodeMode' });
   const result = Result.try({
-    try: () => ToolDefinition.make(definition(tool)),
-    catch: (error) => new RegistrationError({ name: id, message: `Invalid tool definition ${id}: ${schemaMakeError(error)}` })
+    try: () => ToolDefinition.make(definition2(tool)),
+    catch: (error) => new RegistrationError2({ name: id, message: `Invalid tool definition ${id}: ${schemaMakeError(error)}` })
   });
   return Result.isFailure(result) ? result.failure : undefined;
 }
 function namespaceError(name) {
   if (name.split(".").every((segment) => /^[A-Za-z0-9_-]{1,64}$/.test(segment)))
     return;
-  return new RegistrationError({ name, message: `Invalid tool namespace: ${JSON.stringify(name)}` });
+  return new RegistrationError2({ name, message: `Invalid tool namespace: ${JSON.stringify(name)}` });
 }
-var node = makeLocationNode({
-  service: Service,
+var node39 = makeLocationNode({
+  service: Service37,
   layer,
-  deps: [exports_hooks.node, exports_image.node]
+  deps: [node48, node79]
 });
 
-export { RegistrationError, Service, node, exports_tool2 as exports_tool, CallID, Content, Error2 as Error, FileContent, TextContent };
+export { RegistrationError2, Service37, node39, exports_tool, CallID2, Content3, Error2, FileContent3, TextContent2 };

package/dist/chunks/{integration-6vbv4je1.js → command-kvsjn1dr.js}

@@ -1,21 +1,21 @@
 import {
-  InvalidError
-} from "./integration-89ttfx5q.js";
+  InvalidError2
+} from "./command-29x78va6.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/config/variable.ts
 var exports_variable = {};
 __export(exports_variable, {
   ConfigVariable: () => exports_variable,
-  substitute: () => substitute
+  substitute: () => substitute2
 });
 import os from "os";
 import path from "path";
 import { Effect } from "effect";
 import { FSUtil } from "@opencode-ai/util/fs-util";
-var substitute = Effect.fn("ConfigVariable.substitute")(function* (input) {
+var substitute2 = Effect.fn("ConfigVariable.substitute")(function* (input) {
   const text = input.text.replace(/\{env:([^}]+)\}/g, (_, varName) => (input.env?.[varName] ?? process.env[varName]) || "");
   if (!text.includes("{file:"))
     return text;
@@ -46,7 +46,7 @@ var substituteFiles = Effect.fnUntraced(function* (input, text) {
       if (input.missing === "empty")
         return Effect.succeed("");
       const message = `bad file reference: "${token}"`;
-      return Effect.fail(new InvalidError({
+      return Effect.fail(new InvalidError2({
         path: configSource,
         message: error._tag === "PlatformError" && error.reason._tag === "NotFound" ? `${message} ${resolvedPath} does not exist` : message
       }, { cause: error }));
@@ -57,4 +57,4 @@ var substituteFiles = Effect.fnUntraced(function* (input, text) {
   return out + text.slice(cursor);
 });
 
-export { substitute, exports_variable };
+export { substitute2, exports_variable };