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

package/dist/chunks/command-yfbd16n1.js

@@ -0,0 +1,386 @@
+import {
+  SessionMessage2
+} from "./command-982e01ww.js";
+import {
+  __export
+} from "./command-9rqn6x4v.js";
+
+// src/session/message-updater.ts
+var exports_message_updater = {};
+__export(exports_message_updater, {
+  SessionMessageUpdater: () => exports_message_updater,
+  update: () => update2
+});
+import { castDraft, produce } from "immer";
+import { DateTime, Effect, Match, pipe, Schema } from "effect";
+var projectTerminalSnapshot = (draft, event) => {
+  if (event.data.snapshot || event.data.files)
+    draft.snapshot = {
+      ...draft.snapshot,
+      end: event.data.snapshot,
+      files: event.data.files ? Array.from(event.data.files) : undefined
+    };
+};
+function update2(adapter, event) {
+  const created = DateTime.makeUnsafe(event.created);
+  const latestTool = (assistant, id) => assistant.content.findLast((item) => item.type === "tool" && item.id === id);
+  const latestText = (assistant) => assistant.content.findLast((item) => item.type === "text");
+  const latestReasoning = (assistant) => assistant.content.findLast((item) => item.type === "reasoning" && !item.time?.completed);
+  const updateOwnedAssistant = (messageID, recipe) => Effect.gen(function* () {
+    const assistant = yield* adapter.getAssistant(messageID);
+    if (!assistant)
+      return;
+    yield* adapter.updateAssistant(produce(assistant, recipe));
+  });
+  const clearCurrentRetry = Effect.gen(function* () {
+    const assistant = yield* adapter.getCurrentAssistant();
+    if (!assistant?.retry)
+      return;
+    yield* adapter.updateAssistant(produce(assistant, (draft) => {
+      draft.retry = undefined;
+    }));
+  });
+  const project = pipe(Match.type(), Match.discriminatorsExhaustive("type")({
+    "session.created": () => Effect.void,
+    "session.viewed": () => Effect.void,
+    "session.message.content.updated": (event) => updateOwnedAssistant(event.data.messageID, (draft) => {
+      draft.content = castDraft(Schema.decodeUnknownSync(Schema.Array(SessionMessage2.AssistantContent))(event.data.content));
+    }),
+    "session.usage.recorded": () => Effect.void,
+    "session.agent.selected": (event) => Effect.gen(function* () {
+      const previous = event.data.previous ?? (yield* adapter.getAgent());
+      yield* adapter.appendMessage(SessionMessage2.AgentSelected.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "agent-switched",
+        metadata: event.metadata,
+        agent: event.data.agent,
+        previous,
+        time: { created }
+      }));
+    }),
+    "session.model.selected": (event) => Effect.gen(function* () {
+      const previous = event.data.previous ?? (yield* adapter.getModel());
+      yield* adapter.appendMessage(SessionMessage2.ModelSelected.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "model-switched",
+        metadata: event.metadata,
+        model: event.data.model,
+        previous,
+        time: { created }
+      }));
+    }),
+    "session.moved": (event) => Effect.gen(function* () {
+      yield* adapter.appendMessage(SessionMessage2.LocationSwitched.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "location-switched",
+        metadata: event.metadata,
+        location: event.data.location,
+        projectID: event.data.projectID,
+        subpath: event.data.subpath,
+        previous: yield* adapter.getLocation(),
+        time: { created }
+      }));
+    }),
+    "session.renamed": () => Effect.void,
+    "session.deleted": () => Effect.void,
+    "session.forked": () => Effect.void,
+    "session.inbox.delivered": () => Effect.void,
+    "session.inbox.enqueued": () => Effect.void,
+    "session.inbox.cancelled": () => Effect.void,
+    "session.inbox.delivery.changed": () => Effect.void,
+    "session.execution.started": () => Effect.void,
+    "session.execution.succeeded": () => clearCurrentRetry,
+    "session.execution.failed": () => clearCurrentRetry,
+    "session.execution.interrupted": () => clearCurrentRetry,
+    "session.instructions.updated": (event) => {
+      if (event.data.text === undefined)
+        return Effect.void;
+      return adapter.appendMessage(SessionMessage2.System.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "system",
+        text: event.data.text,
+        description: `Instructions updated: ${Object.keys(event.data.delta).join(", ")}`,
+        metadata: event.metadata,
+        time: { created }
+      }));
+    },
+    "session.synthetic": (event) => {
+      return adapter.appendMessage(SessionMessage2.Synthetic.make({
+        text: event.data.text,
+        description: event.data.description,
+        metadata: event.data.metadata,
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "synthetic",
+        time: { created }
+      }));
+    },
+    "session.skill.activated": (event) => {
+      return adapter.appendMessage(SessionMessage2.Skill.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "skill",
+        skill: event.data.id,
+        name: event.data.name,
+        text: event.data.text,
+        metadata: event.metadata,
+        time: { created }
+      }));
+    },
+    "session.shell.started": (event) => {
+      return adapter.appendMessage(SessionMessage2.Shell.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "shell",
+        metadata: event.data.shell.metadata.background === true ? { ...event.metadata, background: true } : event.metadata,
+        shellID: event.data.shell.id,
+        command: event.data.shell.command,
+        status: event.data.shell.status,
+        time: { created }
+      }));
+    },
+    "session.shell.ended": (event) => Effect.gen(function* () {
+      const currentShell = yield* adapter.getShell(event.data.shell.id);
+      if (currentShell) {
+        yield* adapter.updateShell(produce(currentShell, (draft) => {
+          draft.status = event.data.shell.status;
+          draft.exit = event.data.shell.exit;
+          draft.output = event.data.output;
+          draft.time.completed = created;
+        }));
+      }
+    }),
+    "session.step.started": (event) => Effect.gen(function* () {
+      const existing = yield* adapter.getAssistant(event.data.assistantMessageID);
+      if (existing) {
+        yield* adapter.updateAssistant(produce(existing, (draft) => {
+          draft.agent = event.data.agent;
+          draft.model = castDraft(event.data.model);
+          draft.retry = undefined;
+          draft.error = undefined;
+          draft.finish = undefined;
+          draft.rawFinish = undefined;
+          draft.providerState = undefined;
+          draft.time.streamed = undefined;
+          draft.time.completed = undefined;
+          if (event.data.snapshot)
+            draft.snapshot = { ...draft.snapshot, start: event.data.snapshot };
+        }));
+        return;
+      }
+      const currentAssistant = yield* adapter.getCurrentAssistant();
+      if (currentAssistant) {
+        yield* adapter.updateAssistant(produce(currentAssistant, (draft) => {
+          draft.retry = undefined;
+          draft.time.completed = created;
+        }));
+      }
+      yield* adapter.appendMessage(SessionMessage2.Assistant.make({
+        id: event.data.assistantMessageID,
+        type: "assistant",
+        agent: event.data.agent,
+        model: event.data.model,
+        metadata: event.metadata,
+        time: { created },
+        content: [],
+        snapshot: event.data.snapshot ? { start: event.data.snapshot } : undefined
+      }));
+    }),
+    "session.step.streamed": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.time.streamed = created;
+      });
+    },
+    "session.step.ended": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.time.completed = created;
+        draft.finish = event.data.finish;
+        draft.rawFinish = event.data.rawFinish;
+        draft.providerState = castDraft(event.data.providerState);
+        draft.cost = event.data.cost;
+        draft.tokens = event.data.tokens;
+        projectTerminalSnapshot(draft, event);
+      });
+    },
+    "session.step.failed": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.time.completed = created;
+        draft.finish = event.data.finish ?? "error";
+        draft.rawFinish = event.data.rawFinish;
+        draft.providerState = castDraft(event.data.providerState);
+        draft.error = castDraft(event.data.error);
+        draft.retry = undefined;
+        if (event.data.cost !== undefined && event.data.tokens !== undefined) {
+          draft.cost = event.data.cost;
+          draft.tokens = castDraft(event.data.tokens);
+        }
+        projectTerminalSnapshot(draft, event);
+      });
+    },
+    "session.text.started": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.content.push(castDraft(SessionMessage2.AssistantText.make({ type: "text", text: "" })));
+      });
+    },
+    "session.text.ended": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        const match = latestText(draft);
+        if (match) {
+          match.text = event.data.text;
+          match.state = castDraft(event.data.state);
+        }
+      });
+    },
+    "session.tool.input.started": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.content.push(castDraft(SessionMessage2.AssistantTool.make({
+          type: "tool",
+          id: event.data.id,
+          name: event.data.name,
+          time: { created },
+          state: SessionMessage2.ToolStateStreaming.make({ status: "streaming", input: "" })
+        })));
+      });
+    },
+    "session.tool.input.ended": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        const match = latestTool(draft, event.data.id);
+        if (match && match.state.status === "streaming")
+          match.state.input = event.data.text;
+      });
+    },
+    "session.tool.called": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        const match = latestTool(draft, event.data.id);
+        if (match) {
+          match.executed = event.data.executed;
+          match.providerState = event.data.state;
+          match.time.ran = created;
+          match.state = castDraft(SessionMessage2.ToolStateRunning.make({
+            status: "running",
+            input: event.data.input,
+            metadata: {}
+          }));
+        }
+      });
+    },
+    "session.tool.success": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        const match = latestTool(draft, event.data.id);
+        if (match && match.state.status === "running") {
+          match.executed = event.data.executed || match.executed === true;
+          match.providerResultState = event.data.resultState;
+          match.time.completed = created;
+          match.state = castDraft(SessionMessage2.ToolStateCompleted.make({
+            status: "completed",
+            input: match.state.input,
+            content: event.data.content,
+            ...event.data.metadata === undefined ? {} : { metadata: event.data.metadata }
+          }));
+        }
+      });
+    },
+    "session.tool.failed": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        const match = latestTool(draft, event.data.id);
+        if (match && (match.state.status === "streaming" || match.state.status === "running")) {
+          match.executed = event.data.executed || match.executed === true;
+          match.providerResultState = event.data.resultState;
+          match.time.completed = created;
+          match.state = castDraft(SessionMessage2.ToolStateError.make({
+            status: "error",
+            error: event.data.error,
+            input: typeof match.state.input === "string" ? {} : match.state.input,
+            ...event.data.content === undefined ? {} : { content: event.data.content },
+            ...event.data.metadata === undefined ? {} : { metadata: event.data.metadata }
+          }));
+        }
+      });
+    },
+    "session.reasoning.started": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.content.push(castDraft(SessionMessage2.AssistantReasoning.make({
+          type: "reasoning",
+          text: "",
+          state: event.data.state,
+          time: { created }
+        })));
+      });
+    },
+    "session.reasoning.ended": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        const match = latestReasoning(draft);
+        if (match) {
+          match.text = event.data.text;
+          match.time = { created: match.time?.created ?? created, completed: created };
+          if (event.data.state !== undefined)
+            match.state = event.data.state;
+        }
+      });
+    },
+    "session.retry.scheduled": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.retry = {
+          attempt: event.data.attempt,
+          at: DateTime.makeUnsafe(event.data.at),
+          error: castDraft(event.data.error)
+        };
+      });
+    },
+    "session.compaction.started": (event) => adapter.appendMessage(SessionMessage2.CompactionRunning.make({
+      id: event.data.inputID ?? SessionMessage2.ID.fromEvent(event.id),
+      type: "compaction",
+      status: "running",
+      metadata: event.metadata,
+      reason: event.data.reason,
+      summary: "",
+      recent: event.data.recent ?? "",
+      time: { created }
+    })),
+    "session.compaction.ended": (event) => Effect.gen(function* () {
+      const current = yield* adapter.getCompaction();
+      if (current?.status === "running") {
+        yield* adapter.updateCompaction({
+          ...current,
+          status: "completed",
+          reason: event.data.reason,
+          model: event.data.model,
+          providerState: event.data.providerState,
+          summary: event.data.text,
+          recent: event.data.recent
+        });
+        return;
+      }
+      yield* adapter.appendMessage(SessionMessage2.Compaction.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "compaction",
+        status: "completed",
+        metadata: event.metadata,
+        reason: event.data.reason,
+        model: event.data.model,
+        providerState: event.data.providerState,
+        summary: event.data.text,
+        recent: event.data.recent,
+        time: { created }
+      }));
+    }),
+    "session.compaction.failed": (event) => Effect.gen(function* () {
+      const current = yield* adapter.getCompaction();
+      const failed = SessionMessage2.CompactionFailed.make({
+        id: current?.id ?? event.data.inputID ?? SessionMessage2.ID.fromEvent(event.id),
+        type: "compaction",
+        status: "failed",
+        metadata: current?.metadata ?? event.metadata,
+        reason: event.data.reason,
+        error: event.data.error,
+        time: current?.time ?? { created }
+      });
+      if (current?.status === "running")
+        return yield* adapter.updateCompaction(failed);
+      yield* adapter.appendMessage(failed);
+    }),
+    "session.revert.staged": () => Effect.void,
+    "session.revert.cleared": () => Effect.void,
+    "session.revert.committed": () => Effect.void
+  }));
+  return project(event);
+}
+
+export { update2, exports_message_updater };

package/dist/chunks/{integration-eej3r37q.js → command-yzsm82be.js}

@@ -1,76 +1,80 @@
 import {
-  exports_location
-} from "./integration-gpa7n6yh.js";
+  AbsolutePath2,
+  RelativePath2
+} from "./command-p8qxwesx.js";
 import {
-  exports_git
-} from "./integration-qz5gwjr7.js";
+  Repository2,
+  TreeID2,
+  Service70,
+  node73
+} from "./command-mhsg1yty.js";
 import {
-  AbsolutePath,
-  RelativePath
-} from "./integration-j07kk359.js";
+  Service68,
+  node71
+} from "./command-4jcgzkct.js";
 import {
-  exports_state
-} from "./integration-j6s3yjyb.js";
+  create3
+} from "./command-kg06axw8.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/snapshot.ts
-var exports_snapshot = {};
-__export(exports_snapshot, {
-  Error: () => Error,
-  ID: () => ID,
-  Service: () => Service,
-  Snapshot: () => exports_snapshot,
-  node: () => node,
-  noopLayer: () => noopLayer
+var exports_snapshot2 = {};
+__export(exports_snapshot2, {
+  Error: () => Error3,
+  ID: () => ID9,
+  Service: () => Service49,
+  Snapshot: () => exports_snapshot2,
+  node: () => node51,
+  noopLayer: () => noopLayer3
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import path from "path";
 import { Context, Effect, Fiber, Layer, Schema, Scope } from "effect";
 import { FSUtil } from "@opencode-ai/util/fs-util";
 import { Global } from "@opencode-ai/util/global";
-import { ID } from "@opencode-ai/schema/snapshot";
+import { ID as ID9 } from "@opencode-ai/schema/snapshot";
 import { Hash } from "@opencode-ai/util/hash";
-class Error extends Schema.TaggedError()("Snapshot.Error", {
+class Error3 extends Schema.TaggedError()("Snapshot.Error", {
   operation: Schema.Literals(["capture", "files", "diff", "restore"]),
   message: Schema.String,
   cause: Schema.optional(Schema.Defect())
 }) {
 }
 
-class Service extends Context.Service()("@opencode/Snapshot") {
+class Service49 extends Context.Service()("@opencode/Snapshot") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service49, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
-  const git = yield* exports_git.Service;
+  const git = yield* Service70;
   const global = yield* Global.Service;
-  const location = yield* exports_location.Service;
+  const location = yield* Service68;
   const lifetime = yield* Scope.Scope;
-  const state = exports_state.create({
+  const state = create3({
     name: "snapshot",
     initial: () => ({ enabled: true }),
     editor: (editor) => ({
-      configure: (enabled2) => {
-        editor.enabled = enabled2;
+      configure: (enabled) => {
+        editor.enabled = enabled;
       }
     })
   });
   const repositoryFiber = yield* Effect.cached(Effect.gen(function* () {
     const source = yield* git.repo.discover(location.project.directory);
     if (!source)
-      return yield* new Error({ operation: "capture", message: "Project is not a Git repository" });
-    const worktree = AbsolutePath.make(yield* fs.realPath(source.worktree).pipe(Effect.orDie));
-    const gitDirectory = AbsolutePath.make(path.join(global.data, "snapshot", location.project.id, Hash.fast(worktree)));
-    const snapshotRepository = (yield* fs.existsSafe(path.join(gitDirectory, "HEAD"))) ? new exports_git.Repository({ worktree, gitDirectory, commonDirectory: gitDirectory }) : yield* git.repo.create({ worktree, gitDirectory, seed: source }).pipe(Effect.mapError((cause) => failure("capture", cause)));
+      return yield* new Error3({ operation: "capture", message: "Project is not a Git repository" });
+    const worktree = AbsolutePath2.make(yield* fs.realPath(source.worktree).pipe(Effect.orDie));
+    const gitDirectory = AbsolutePath2.make(path.join(global.data, "snapshot", location.project.id, Hash.fast(worktree)));
+    const snapshotRepository = (yield* fs.existsSafe(path.join(gitDirectory, "HEAD"))) ? new Repository2({ worktree, gitDirectory, commonDirectory: gitDirectory }) : yield* git.repo.create({ worktree, gitDirectory, seed: source }).pipe(Effect.mapError((cause) => failure("capture", cause)));
     return { source, worktree, snapshotRepository };
   }).pipe(Effect.forkIn(lifetime)));
   const repository = repositoryFiber.pipe(Effect.uninterruptible, Effect.flatMap(Fiber.join));
   const scope = Effect.fnUntraced(function* (worktree) {
     const relative = path.relative(worktree, location.directory);
     if (relative.startsWith("..") || path.isAbsolute(relative))
-      return yield* new Error({ operation: "capture", message: "Location is outside the project" });
-    return RelativePath.make(relative.replaceAll("\\", "/") || ".");
+      return yield* new Error3({ operation: "capture", message: "Location is outside the project" });
+    return RelativePath2.make(relative.replaceAll("\\", "/") || ".");
   });
   const enabled = () => location.vcs?.type === "git" && state.get().enabled;
   const capture = Effect.fn("Snapshot.capture")(function* () {
@@ -78,7 +82,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       return;
     return yield* Effect.gen(function* () {
       const repo = yield* repository;
-      return ID.make(yield* git.tree.capture({
+      return ID9.make(yield* git.tree.capture({
         repository: repo.snapshotRepository,
         scopes: [yield* scope(repo.worktree)],
         ignores: repo.source,
@@ -90,14 +94,14 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const repo = yield* repository.pipe(Effect.mapError((cause) => failure(operation, cause)));
     const comparison = {
       repository: repo.snapshotRepository,
-      from: exports_git.TreeID.make(input.from),
-      to: exports_git.TreeID.make(input.to)
+      from: TreeID2.make(input.from),
+      to: TreeID2.make(input.to)
     };
-    const files2 = yield* git.tree.files(comparison).pipe(Effect.mapError((cause) => failure(operation, cause)));
-    const ignored = yield* git.index.ignored({ repository: repo.source, paths: files2 }).pipe(Effect.mapError((cause) => failure(operation, cause)));
+    const files = yield* git.tree.files(comparison).pipe(Effect.mapError((cause) => failure(operation, cause)));
+    const ignored = yield* git.index.ignored({ repository: repo.source, paths: files }).pipe(Effect.mapError((cause) => failure(operation, cause)));
     return {
       input: comparison,
-      files: files2,
+      files,
       ignored
     };
   });
@@ -114,29 +118,29 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     }).pipe(Effect.mapError((cause) => failure("diff", cause)));
   });
   const plan = Effect.fnUntraced(function* (worktree, input) {
-    const files2 = new Map;
+    const files = new Map;
     for (const [file, snapshot] of input.files) {
       const absolute = path.resolve(worktree, file);
       if (!FSUtil.contains(worktree, absolute))
-        return yield* new Error({ operation: "restore", message: `Path escapes the project: ${file}` });
-      files2.set(file, exports_git.TreeID.make(snapshot));
+        return yield* new Error3({ operation: "restore", message: `Path escapes the project: ${file}` });
+      files.set(file, TreeID2.make(snapshot));
     }
-    return files2;
+    return files;
   });
   const restore = Effect.fn("Snapshot.restore")(function* (input) {
     if (!enabled())
-      return yield* new Error({ operation: "restore", message: "Snapshots are disabled" });
+      return yield* new Error3({ operation: "restore", message: "Snapshots are disabled" });
     const repo = yield* repository.pipe(Effect.mapError((cause) => failure("restore", cause)));
     yield* git.tree.restore({ repository: repo.snapshotRepository, files: yield* plan(repo.worktree, input) }).pipe(Effect.mapError((cause) => failure("restore", cause)));
   });
-  return Service.of({ transform: state.transform, reload: state.reload, capture, files, diff, restore });
+  return Service49.of({ transform: state.transform, reload: state.reload, capture, files, diff, restore });
 }).pipe(Effect.withSpan("Snapshot.boot")));
-var node = makeLocationNode({
-  service: Service,
+var node51 = makeLocationNode({
+  service: Service49,
   layer,
-  deps: [FSUtil.node, exports_git.node, Global.node, exports_location.node]
+  deps: [FSUtil.node, node73, Global.node, node71]
 });
-var noopLayer = Layer.succeed(Service, Service.of({
+var noopLayer3 = Layer.succeed(Service49, Service49.of({
   transform: () => Effect.succeed({ dispose: Effect.void }),
   reload: () => Effect.void,
   capture: () => Effect.undefined,
@@ -145,13 +149,13 @@ var noopLayer = Layer.succeed(Service, Service.of({
   restore: () => Effect.void
 }));
 function failure(operation, cause) {
-  if (cause instanceof Error && cause.operation === operation)
+  if (cause instanceof Error3 && cause.operation === operation)
     return cause;
-  return new Error({
+  return new Error3({
     operation,
     message: cause instanceof globalThis.Error ? cause.message : String(cause),
     cause
   });
 }
 
-export { ID, Error, Service, node, noopLayer, exports_snapshot };
+export { ID9, Error3, Service49, node51, noopLayer3, exports_snapshot2 };

package/dist/chunks/{integration-hvydqsq5.js → command-z1k01bn4.js}

@@ -1,17 +1,17 @@
 import {
-  Failed,
-  NotFound,
-  WrongKind
-} from "./integration-vynk8zbr.js";
+  NotFound2,
+  WrongKind2,
+  Failed2
+} from "./command-2a5m3afh.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/environment/exec-defaults.ts
 var exports_exec_defaults = {};
 __export(exports_exec_defaults, {
   EnvironmentExecDefaults: () => exports_exec_defaults,
-  execDefaults: () => execDefaults
+  execDefaults: () => execDefaults2
 });
 import { Effect, Stream } from "effect";
 import { ChildProcess } from "effect/unstable/process";
@@ -63,21 +63,21 @@ var moveScript = `
 ${loadMetadata()}
 mv -- "$1" "$2"
 `;
-var execDefaults = (spawner) => {
+var execDefaults2 = (spawner) => {
   const run = (path, script, args = [], stdin) => Effect.scoped(Effect.gen(function* () {
     const command = ChildProcess.make("sh", ["-c", script, "sh", path, ...args], {
       env: { LC_ALL: "C" },
       extendEnv: true,
       stdin: stdin === undefined ? undefined : Stream.make(stdin)
     });
-    const handle = yield* spawner.spawn(command).pipe(Effect.mapError((cause) => new Failed({ path, cause })));
+    const handle = yield* spawner.spawn(command).pipe(Effect.mapError((cause) => new Failed2({ path, cause })));
     const [stdout, stderr, exitCode] = yield* Effect.all([
       collectStream(handle.stdout, MAX_DATA_BYTES),
       collectStream(handle.stderr, MAX_ERROR_BYTES),
       handle.exitCode
-    ], { concurrency: "unbounded" }).pipe(Effect.mapError((cause) => new Failed({ path, cause })));
+    ], { concurrency: "unbounded" }).pipe(Effect.mapError((cause) => new Failed2({ path, cause })));
     if (stdout.truncated || stderr.truncated) {
-      return yield* new Failed({ path, cause: new Error("Process output exceeded its collection limit") });
+      return yield* new Failed2({ path, cause: new Error("Process output exceeded its collection limit") });
     }
     return { exitCode, stdout: stdout.buffer, stderr: stderr.buffer };
   }));
@@ -85,9 +85,9 @@ var execDefaults = (spawner) => {
     if (result.exitCode === 0)
       return Effect.sync(() => success(result.stdout));
     if (result.exitCode === NOT_FOUND)
-      return Effect.fail(new NotFound({ path }));
+      return Effect.fail(new NotFound2({ path }));
     if (result.exitCode === WRONG_KIND) {
-      return Effect.fail(new WrongKind({ path, actual: parseType(new TextDecoder().decode(result.stderr)) }));
+      return Effect.fail(new WrongKind2({ path, actual: parseType(new TextDecoder().decode(result.stderr)) }));
     }
     return Effect.fail(processFailure(path, result));
   };
@@ -116,10 +116,10 @@ var classifyPlain = (path, result, success) => {
   if (result.exitCode === 0)
     return Effect.sync(() => success(result.stdout));
   if (result.exitCode === NOT_FOUND)
-    return Effect.fail(new NotFound({ path }));
+    return Effect.fail(new NotFound2({ path }));
   return Effect.fail(processFailure(path, result));
 };
-var processFailure = (path, result) => new Failed({
+var processFailure = (path, result) => new Failed2({
   path,
   cause: new Error(new TextDecoder().decode(result.stderr).trim() || `Process exited with code ${result.exitCode}`)
 });
@@ -151,4 +151,4 @@ var parseList = (bytes) => {
   }));
 };
 
-export { execDefaults, exports_exec_defaults };
+export { execDefaults2, exports_exec_defaults };