@opencode-ai/core 0.0.0-beta-18743 → 0.0.0-beta-18866

package/dist/chunks/{websearch-h7xf8fhv.js → reference-3y28g1fq.js}

@@ -1,34 +1,34 @@
 import {
   exports_repository
-} from "./websearch-y198y2ra.js";
+} from "./reference-s32nnj3r.js";
+import {
+  exports_kv
+} from "./reference-9s00a4cy.js";
 import {
   exports_git
-} from "./websearch-dyj7wa6j.js";
+} from "./reference-qz5gwjr7.js";
 import {
   AbsolutePath
-} from "./websearch-j07kk359.js";
-import {
-  exports_kv
-} from "./websearch-8rq9vje0.js";
+} from "./reference-j07kk359.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./reference-vpjkya7h.js";
 
 // src/repository-cache.ts
 var exports_repository_cache = {};
 __export(exports_repository_cache, {
-  validateBranch: () => validateBranch,
-  node: () => node,
-  isError: () => isError,
-  Service: () => Service,
-  ResetFailedError: () => ResetFailedError,
-  RepositoryCache: () => exports_repository_cache,
-  LockFailedError: () => LockFailedError,
-  InvalidBranchError: () => InvalidBranchError,
-  FetchFailedError: () => FetchFailedError,
-  CloneFailedError: () => CloneFailedError,
+  CacheOperationError: () => CacheOperationError,
   CheckoutFailedError: () => CheckoutFailedError,
-  CacheOperationError: () => CacheOperationError
+  CloneFailedError: () => CloneFailedError,
+  FetchFailedError: () => FetchFailedError,
+  InvalidBranchError: () => InvalidBranchError,
+  LockFailedError: () => LockFailedError,
+  RepositoryCache: () => exports_repository_cache,
+  ResetFailedError: () => ResetFailedError,
+  Service: () => Service,
+  isError: () => isError,
+  node: () => node,
+  validateBranch: () => validateBranch
 });
 import path from "path";
 import { Clock, Context, Duration, Effect, Layer, Option, Schema } from "effect";

package/dist/chunks/reference-424hja68.js

@@ -0,0 +1,196 @@
+import {
+  exports_service
+} from "./reference-6bxzghb6.js";
+import {
+  exports_mime
+} from "./reference-kq3q54gz.js";
+import {
+  exports_image
+} from "./reference-qx3jf2qk.js";
+import {
+  exports_skill
+} from "./reference-k3b0087g.js";
+import {
+  AttachmentError,
+  SkillNotFoundError
+} from "./reference-2sqw2jjm.js";
+import {
+  exports_hooks
+} from "./reference-xws7arpm.js";
+import {
+  __export
+} from "./reference-vpjkya7h.js";
+
+// src/session/prompt.ts
+var exports_prompt = {};
+__export(exports_prompt, {
+  SessionPrompt: () => exports_prompt,
+  prepare: () => prepare
+});
+import { Base64, FileAttachment, Prompt } from "@opencode-ai/schema/prompt";
+import { SessionInbox } from "@opencode-ai/schema/session-inbox";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Effect } from "effect";
+import path from "path";
+import { fileURLToPath } from "url";
+var prepare = Effect.fn("SessionPrompt.prepare")(function* (request) {
+  const fs = yield* FSUtil.Service;
+  const instances = yield* exports_service.Service;
+  return yield* Effect.gen(function* () {
+    const hooks = yield* exports_hooks.Service;
+    const event = yield* hooks.trigger("session", "prompt", {
+      sessionID: request.session.id,
+      messageID: request.messageID,
+      prompt: structuredClone({
+        text: request.input.text,
+        files: request.input.files?.slice(),
+        agents: request.input.agents?.slice(),
+        skills: request.input.skills?.slice()
+      }),
+      metadata: structuredClone(request.input.metadata),
+      delivery: request.input.delivery ?? "steer"
+    });
+    const input = event.prompt;
+    const files = input.files ? yield* Effect.forEach(input.files, materializeAttachment, { concurrency: 8 }) : undefined;
+    const requested = input.skills;
+    const selected = yield* Effect.gen(function* () {
+      if (!requested?.length)
+        return;
+      const skillService = yield* exports_skill.Service;
+      const prepared = new Map;
+      return yield* Effect.forEach(requested, (attachment) => Effect.gen(function* () {
+        const name = prepared.get(attachment.id);
+        if (name !== undefined)
+          return { id: attachment.id, name, mention: attachment.mention };
+        const skill = yield* skillService.get(attachment.id);
+        if (!skill)
+          return yield* new SkillNotFoundError({ skill: attachment.id });
+        prepared.set(skill.id, skill.name);
+        return {
+          id: skill.id,
+          name: skill.name,
+          text: (yield* exports_skill.prepare(fs, skill).pipe(Effect.orDie)).output,
+          mention: attachment.mention
+        };
+      }));
+    });
+    return {
+      type: "user",
+      payload: SessionInbox.UserPayload.make({
+        ...Prompt.make({
+          text: input.text,
+          agents: input.agents,
+          files,
+          skills: selected?.length ? selected : undefined
+        }),
+        metadata: event.metadata
+      }),
+      delivery: SessionInbox.Delivery.make(event.delivery)
+    };
+  }).pipe(instances.provide(request.session));
+});
+var materializeAttachment = Effect.fn("SessionPrompt.materializeAttachment")(function* (input) {
+  const resolved = input.uri.startsWith("data:") ? {
+    bytes: yield* decodeDataURL(input.uri),
+    source: { type: "inline" },
+    start: undefined,
+    end: undefined,
+    name: undefined,
+    mime: undefined
+  } : yield* readFileAttachment(input.uri);
+  if (resolved.bytes.byteLength > MAX_ATTACHMENT_BYTES)
+    return yield* new AttachmentError({
+      uri: input.uri,
+      message: `Attachment exceeds the ${MAX_ATTACHMENT_BYTES} byte limit: ${input.uri}`
+    });
+  const mime = resolved.mime ?? exports_mime.detect(resolved.bytes);
+  const content = mime === "text/plain" && resolved.start !== undefined ? Buffer.from(Buffer.from(resolved.bytes).toString("utf8").split(`
+`).slice(resolved.start - 1, resolved.end).join(`
+`)) : resolved.bytes;
+  const normalized = yield* normalizeImageAttachment(input, Buffer.from(content).toString("base64"), mime);
+  return FileAttachment.create({
+    data: normalized.data,
+    mime: normalized.mime,
+    source: resolved.source,
+    name: input.name ?? resolved.name,
+    description: input.description,
+    mention: input.mention
+  });
+});
+var normalizeImageAttachment = Effect.fn("SessionPrompt.normalizeImageAttachment")(function* (input, data, mime) {
+  if (!mime.startsWith("image/"))
+    return { data: Base64.make(data), mime };
+  const image = yield* exports_image.Service;
+  const label = input.name ?? (input.uri.startsWith("data:") ? "inline attachment" : input.uri);
+  const content = { uri: label, content: data, encoding: "base64", mime };
+  const normalized = yield* image.normalize(label, content).pipe(Effect.catchTag("Image.ResizerUnavailableError", () => Effect.succeed(content)), Effect.mapError((error) => new AttachmentError({ uri: label, message: error.message })));
+  return { data: Base64.make(normalized.content), mime: normalized.mime };
+});
+var readFileAttachment = Effect.fn("SessionPrompt.readFileAttachment")(function* (uri) {
+  const fs = yield* FSUtil.Service;
+  const url = yield* Effect.try({
+    try: () => new URL(uri),
+    catch: () => new AttachmentError({ uri, message: `Invalid attachment URI: ${uri}` })
+  });
+  if (url.protocol !== "file:")
+    return yield* new AttachmentError({ uri, message: `Unsupported attachment URI: ${uri}` });
+  const start = positiveInt(url.searchParams.get("start"));
+  const end = positiveInt(url.searchParams.get("end"));
+  const target = yield* Effect.try({
+    try: () => {
+      url.search = "";
+      url.hash = "";
+      return fileURLToPath(url);
+    },
+    catch: () => new AttachmentError({ uri, message: `Invalid file URI: ${uri}` })
+  });
+  const info = yield* fs.stat(target).pipe(Effect.mapError(() => new AttachmentError({ uri, message: `Unable to read attachment: ${uri}` })));
+  if (info.type === "Directory") {
+    const entries = yield* fs.readDirectoryEntries(target).pipe(Effect.mapError(() => new AttachmentError({ uri, message: `Unable to read attachment: ${uri}` })));
+    return {
+      bytes: Buffer.from(entries.filter((entry) => entry.type === "file" || entry.type === "directory").sort((a, b) => a.type === b.type ? a.name.localeCompare(b.name) : a.type === "directory" ? -1 : 1).map((entry) => entry.name + (entry.type === "directory" ? path.sep : "")).join(`
+`)),
+      source: { type: "uri", uri },
+      start: undefined,
+      end: undefined,
+      name: path.basename(target),
+      mime: "application/x-directory"
+    };
+  }
+  if (info.type !== "File")
+    return yield* new AttachmentError({ uri, message: `Attachment is not a file: ${uri}` });
+  if (Number(info.size) > MAX_ATTACHMENT_BYTES)
+    return yield* new AttachmentError({
+      uri,
+      message: `Attachment exceeds the ${MAX_ATTACHMENT_BYTES} byte limit: ${uri}`
+    });
+  const bytes = yield* fs.readFile(target).pipe(Effect.mapError(() => new AttachmentError({ uri, message: `Unable to read attachment: ${uri}` })));
+  return { bytes, source: { type: "uri", uri }, start, end, name: path.basename(target), mime: undefined };
+});
+var MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
+function decodeDataURL(uri) {
+  return Effect.try({
+    try: () => {
+      const comma = uri.indexOf(",");
+      if (comma === -1)
+        throw new Error("Invalid data URL");
+      const metadata = uri.slice(5, comma);
+      const payload = uri.slice(comma + 1);
+      if (!metadata.split(";").some((part) => part.toLowerCase() === "base64"))
+        return Buffer.from(decodeURIComponent(payload));
+      const bytes = Buffer.from(payload, "base64");
+      if (bytes.toString("base64") !== payload)
+        throw new Error("Non-canonical base64");
+      return bytes;
+    },
+    catch: () => new AttachmentError({ uri, message: "Invalid attachment data URL" })
+  });
+}
+function positiveInt(value) {
+  if (value === null)
+    return;
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+export { prepare, exports_prompt };

package/dist/chunks/{websearch-thstd87d.js → reference-42zyazrq.js}

@@ -1,12 +1,12 @@
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./reference-vpjkya7h.js";
 
 // src/v1/config/command.ts
 var exports_command = {};
 __export(exports_command, {
-  Info: () => Info,
-  ConfigCommandV1: () => exports_command
+  ConfigCommandV1: () => exports_command,
+  Info: () => Info
 });
 import { Schema } from "effect";
 var Info = Schema.Struct({

package/dist/chunks/{websearch-69gn2r8j.js → reference-46azr2y9.js}

@@ -1,19 +1,19 @@
 import {
   exports_skill
-} from "./websearch-h8nbdcx9.js";
+} from "./reference-k3b0087g.js";
 import {
   exports_instructions
-} from "./websearch-ec8vrfw5.js";
+} from "./reference-c54e84vp.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./reference-vpjkya7h.js";
 
 // src/skill/instructions.ts
 var exports_instructions2 = {};
 __export(exports_instructions2, {
-  node: () => node,
+  Service: () => Service,
   SkillInstructions: () => exports_instructions2,
-  Service: () => Service
+  node: () => node
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";

package/dist/chunks/{websearch-16zkvt3y.js → reference-4e9y157d.js}

@@ -1,9 +1,9 @@
 import {
   exports_integration
-} from "./websearch-0atc81xx.js";
+} from "./reference-ak8kj9h3.js";
 import {
   exports_provider
-} from "./websearch-fex42j86.js";
+} from "./reference-zq5w46q0.js";
 
 // src/plugin/provider/llmgateway.ts
 import { Effect } from "effect";

package/dist/chunks/{websearch-10p29vm9.js → reference-4qz7zhx0.js}

@@ -1,17 +1,17 @@
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./reference-vpjkya7h.js";
 
 // src/plugin/system-prompt.ts
 var exports_system_prompt = {};
 __export(exports_system_prompt, {
-  SystemPromptPlugin: () => exports_system_prompt,
-  Plugins: () => Plugins,
-  OpenAIPlugin: () => OpenAIPlugin,
-  MetaPlugin: () => MetaPlugin,
-  KimiPlugin: () => KimiPlugin,
+  AnthropicPlugin: () => AnthropicPlugin,
   ArceePlugin: () => ArceePlugin,
-  AnthropicPlugin: () => AnthropicPlugin
+  KimiPlugin: () => KimiPlugin,
+  MetaPlugin: () => MetaPlugin,
+  OpenAIPlugin: () => OpenAIPlugin,
+  Plugins: () => Plugins,
+  SystemPromptPlugin: () => exports_system_prompt
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect } from "effect";

package/dist/chunks/{websearch-5sc277j1.js → reference-4v53bvyt.js}

@@ -1,43 +1,43 @@
 import {
   exports_watcher
-} from "./websearch-ns0sdez7.js";
+} from "./reference-wkcm2121.js";
 import {
   exports_variable
-} from "./websearch-d2gk9vpf.js";
+} from "./reference-6vbv4je1.js";
 import {
   exports_normalize
-} from "./websearch-58qy95wc.js";
-import {
-  exports_wellknown
-} from "./websearch-1b8q0qfd.js";
+} from "./reference-e5r3hp5p.js";
 import {
   exports_credential
-} from "./websearch-xz7tgbq3.js";
+} from "./reference-thngpag9.js";
 import {
-  exports_location
-} from "./websearch-mp6zts7p.js";
+  exports_wellknown
+} from "./reference-k85ch1vg.js";
 import {
-  exports_bus
-} from "./websearch-cat9v99r.js";
+  exports_location
+} from "./reference-pp6802x5.js";
 import {
   AbsolutePath
-} from "./websearch-j07kk359.js";
+} from "./reference-j07kk359.js";
+import {
+  exports_bus
+} from "./reference-jghhn6h0.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./reference-vpjkya7h.js";
 
 // src/config.ts
 var exports_config = {};
 __export(exports_config, {
-  testLayer: () => testLayer,
-  node: () => node,
-  layer: () => layer,
-  latest: () => latest,
-  configured: () => configured,
-  Test: () => Test,
-  Service: () => Service,
+  Config: () => exports_config,
   Options: () => Options,
-  Config: () => exports_config
+  Service: () => Service,
+  Test: () => Test,
+  configured: () => configured,
+  latest: () => latest,
+  layer: () => layer,
+  node: () => node,
+  testLayer: () => testLayer
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import path from "path";

package/dist/chunks/{websearch-2nmyybe0.js → reference-4v6g3p22.js}

@@ -1,13 +1,13 @@
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./reference-vpjkya7h.js";
 
 // src/v1/config/formatter.ts
 var exports_formatter = {};
 __export(exports_formatter, {
-  Info: () => Info,
+  ConfigFormatterV1: () => exports_formatter,
   Entry: () => Entry,
-  ConfigFormatterV1: () => exports_formatter
+  Info: () => Info
 });
 import { Schema } from "effect";
 var Entry = Schema.Struct({

package/dist/chunks/{websearch-5ps159h2.js → reference-4z6b1r7t.js}

@@ -1,33 +1,30 @@
 import {
-  exports_prompt
-} from "./websearch-xtjf5v78.js";
+  exports_revert
+} from "./reference-z6zhg99y.js";
 import {
   exports_execution
-} from "./websearch-abv0a2s2.js";
+} from "./reference-9ex87gzq.js";
+import {
+  exports_shell
+} from "./reference-dvqebtf1.js";
 import {
   exports_inbox
-} from "./websearch-2ygx7nw7.js";
+} from "./reference-3t5c6jt3.js";
 import {
-  exports_revert
-} from "./websearch-w06zjwdb.js";
+  exports_prompt
+} from "./reference-424hja68.js";
 import {
-  exports_supervisor_service
-} from "./websearch-s33fw6zm.js";
+  exports_skill
+} from "./reference-fkdrrz2d.js";
 import {
-  exports_shell
-} from "./websearch-44bp186z.js";
+  exports_service
+} from "./reference-6bxzghb6.js";
 import {
   exports_result
-} from "./websearch-etvrgfqj.js";
-import {
-  exports_skill
-} from "./websearch-h8nbdcx9.js";
-import {
-  exports_reference
-} from "./websearch-q8xy3s52.js";
+} from "./reference-5y5kqjze.js";
 import {
   exports_store
-} from "./websearch-8axmdjr3.js";
+} from "./reference-bwqptwn6.js";
 import {
   BusyError,
   CompactionConflictError,
@@ -38,35 +35,41 @@ import {
   MessageToolIncompleteError,
   NotFoundError,
   PromptConflictError,
-  SkillNotFoundError,
   SyntheticConflictError
-} from "./websearch-cgqn2mrm.js";
+} from "./reference-2sqw2jjm.js";
+import {
+  SessionMessage
+} from "./reference-8rpfd2h6.js";
 import {
   SessionEvent
-} from "./websearch-a83yvq99.js";
+} from "./reference-a83yvq99.js";
 import {
   exports_bus
-} from "./websearch-cat9v99r.js";
+} from "./reference-jghhn6h0.js";
 import {
-  SessionMessage
-} from "./websearch-8rpfd2h6.js";
+  exports_database
+} from "./reference-xwpxh8hr.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./reference-vpjkya7h.js";
 
 // src/session/session.ts
 var exports_session = {};
 __export(exports_session, {
-  make: () => make,
-  Session: () => exports_session
+  Session: () => exports_session,
+  make: () => make
 });
 import { DateTime, Effect, Fiber, Schema, Scope } from "effect";
 import { Event } from "@opencode-ai/schema/event";
-var make = Effect.fn("Session.make")(function* (servicesFor) {
+import { FSUtil } from "@opencode-ai/util/fs-util";
+var make = Effect.fn("Session.make")(function* () {
   const bus = yield* exports_bus.Service;
+  const database = yield* exports_database.Service;
   const store = yield* exports_store.Service;
+  const instances = yield* exports_service.Service;
   const execution = yield* exports_execution.Service;
   const admission = yield* exports_inbox.Service;
+  const fs = yield* FSUtil.Service;
   const scope = yield* Scope.Scope;
   const get = Effect.fn("Session.get")(function* (sessionID) {
     const session = yield* store.get(sessionID);
@@ -147,20 +150,14 @@ var make = Effect.fn("Session.make")(function* (servicesFor) {
       });
       if (existing)
         return existing;
-      const prepared = yield* restore(Effect.gen(function* () {
-        const preparation = yield* exports_prompt.Service;
-        const references = yield* exports_reference.Service;
-        return { item: yield* preparation.prepare({ sessionID, messageID, input }), references };
-      }).pipe(Effect.provide(servicesFor(session.location))));
+      const item = yield* restore(exports_prompt.prepare({ session, messageID, input }).pipe(Effect.provideService(exports_service.Service, instances), Effect.provideService(FSUtil.Service, fs)));
       if (session.revert)
         yield* exports_revert.commit(bus, session);
-      const admitted2 = yield* admission.admit({
+      return yield* admission.admit({
         id: messageID,
         sessionID: session.id,
-        item: prepared.item
+        item
       });
-      yield* prepared.references.refresh();
-      return admitted2;
     }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => new PromptConflictError({ sessionID, messageID })));
     if (input.resume !== false)
       yield* execution.wake(sessionID);
@@ -169,17 +166,7 @@ var make = Effect.fn("Session.make")(function* (servicesFor) {
   const shell = Effect.fn("Session.shell")(function* (sessionID, input) {
     const session = yield* get(sessionID);
     const running = yield* Effect.gen(function* () {
-      const shell2 = yield* Effect.gen(function* () {
-        const plugins = yield* exports_supervisor_service.Service;
-        yield* plugins.flush;
-        return yield* exports_shell.Service;
-      }).pipe(Effect.provide(servicesFor(session.location)));
-      const started = yield* shell2.create({
-        command: input.command,
-        cwd: session.location.directory,
-        timeout: 0,
-        metadata: { sessionID, background: true }
-      }).pipe(Effect.tapError((error) => synthetic(sessionID, {
+      const started = yield* exports_shell.start({ session, command: input.command }).pipe(Effect.provideService(exports_service.Service, instances), Effect.tapError((error) => synthetic(sessionID, {
         text: `User shell command failed to start:
 ${input.command}
 
@@ -190,10 +177,10 @@ ${error.message}`,
       })), Effect.orDie);
       yield* bus.publish(SessionEvent.Shell.Started, {
         sessionID,
-        shell: started
+        shell: started.info
       }, { id: input.id });
-      const terminal = yield* shell2.result(started);
-      const preview = yield* shell2.output(started.id, { limit: SHELL_MAX_CAPTURE_BYTES }).pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.succeed(exports_result.unavailable)));
+      const terminal = yield* started.result;
+      const preview = yield* started.output;
       yield* bus.publish(SessionEvent.Shell.Ended, {
         sessionID,
         shell: terminal.info,
@@ -208,10 +195,7 @@ ${error.message}`,
   });
   const skill = Effect.fn("Session.skill")(function* (sessionID, input) {
     const session = yield* get(sessionID);
-    const skills = yield* exports_skill.Service.pipe(Effect.provide(servicesFor(session.location)));
-    const skill2 = yield* skills.get(input.skill);
-    if (!skill2)
-      return yield* new SkillNotFoundError({ skill: input.skill });
+    const skill2 = yield* exports_skill.get({ session, skill: input.skill }).pipe(Effect.provideService(exports_service.Service, instances));
     yield* bus.publish(SessionEvent.Skill.Activated, {
       sessionID,
       id: skill2.id,
@@ -268,13 +252,13 @@ ${error.message}`,
     const session = yield* get(sessionID);
     if (yield* execution.isActive(sessionID))
       return yield* new BusyError({ sessionID });
-    return yield* exports_revert.Service.use((revert2) => revert2.stage({ session, messageID: input.messageID, files: input.files })).pipe(Effect.provide(servicesFor(session.location)));
+    return yield* exports_revert.stage({ session, messageID: input.messageID, files: input.files }).pipe(Effect.provideService(exports_service.Service, instances), Effect.provideService(exports_database.Service, database), Effect.provideService(exports_bus.Service, bus));
   });
   const clear = Effect.fn("Session.revert.clear")(function* (sessionID) {
     const session = yield* get(sessionID);
     if (yield* execution.isActive(sessionID))
       return yield* new BusyError({ sessionID });
-    yield* exports_revert.Service.use((revert2) => revert2.clear(session)).pipe(Effect.provide(servicesFor(session.location)));
+    yield* exports_revert.clear(session).pipe(Effect.provideService(exports_service.Service, instances), Effect.provideService(exports_bus.Service, bus));
     return yield* execution.wake(sessionID);
   });
   const commit = Effect.fn("Session.revert.commit")(function* (sessionID) {
@@ -359,6 +343,5 @@ ${error.message}`,
 function isUnfinishedTool(content) {
   return content.type === "tool" && (content.state.status === "streaming" || content.state.status === "running");
 }
-var SHELL_MAX_CAPTURE_BYTES = 1024 * 1024;
 
 export { make, exports_session };

package/dist/chunks/{websearch-pdzzmdc7.js → reference-5400f3k2.js}

@@ -1,35 +1,35 @@
 import {
   ID
-} from "./websearch-tvmhrvfj.js";
+} from "./reference-tvmhrvfj.js";
 import {
   lazy
-} from "./websearch-8w9tzfz1.js";
-import {
-  exports_select
-} from "./websearch-bbhffenw.js";
+} from "./reference-8w9tzfz1.js";
 import {
   exports_location
-} from "./websearch-mp6zts7p.js";
+} from "./reference-pp6802x5.js";
+import {
+  exports_select
+} from "./reference-6f6thqyy.js";
 import {
   exports_bus
-} from "./websearch-cat9v99r.js";
+} from "./reference-jghhn6h0.js";
 import {
   __export,
   __require
-} from "./websearch-rvfvac9x.js";
+} from "./reference-vpjkya7h.js";
 
 // src/pty.ts
 var exports_pty = {};
 __export(exports_pty, {
-  node: () => node,
-  UpdateInput: () => UpdateInput,
-  Service: () => Service,
-  Pty: () => exports_pty,
-  NotFoundError: () => NotFoundError,
-  Info: () => Info,
-  ExitedError: () => ExitedError,
+  CreateInput: () => CreateInput,
   Event: () => Event,
-  CreateInput: () => CreateInput
+  ExitedError: () => ExitedError,
+  Info: () => Info,
+  NotFoundError: () => NotFoundError,
+  Pty: () => exports_pty,
+  Service: () => Service,
+  UpdateInput: () => UpdateInput,
+  node: () => node
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";