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

package/dist/chunks/{instance-9av6q7y3.js → kv-8brfdvrk.js}

@@ -1,57 +1,58 @@
 import {
-  exports_mime
-} from "./instance-kq3q54gz.js";
+  NonNegativeInt2,
+  PositiveInt2,
+  RelativePath2
+} from "./kv-p8qxwesx.js";
 import {
-  exports_filesystem
-} from "./instance-1b3ejbt8.js";
+  Service62,
+  node65
+} from "./kv-94exngkb.js";
 import {
-  exports_environment1 as exports_environment
-} from "./instance-qzx3gxz5.js";
+  Content3
+} from "./kv-sdrecbr4.js";
 import {
-  NonNegativeInt,
-  PositiveInt,
-  RelativePath
-} from "./instance-j07kk359.js";
+  detect2
+} from "./kv-3smtnn6g.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/tool/read-filesystem.ts
 var exports_read_filesystem = {};
 __export(exports_read_filesystem, {
-  BinaryFileError: () => BinaryFileError,
-  FileContent: () => FileContent,
-  ListEntry: () => ListEntry,
-  ListPage: () => ListPage,
-  MAX_MEDIA_INGEST_BYTES: () => MAX_MEDIA_INGEST_BYTES,
-  MAX_READ_BYTES: () => MAX_READ_BYTES,
-  MAX_READ_LINES: () => MAX_READ_LINES,
-  MEDIA_MIMES: () => MEDIA_MIMES,
-  MediaIngestLimitError: () => MediaIngestLimitError,
-  OffsetOutOfRangeError: () => OffsetOutOfRangeError,
-  PageInput: () => PageInput,
-  PathKindError: () => PathKindError,
+  BinaryFileError: () => BinaryFileError2,
+  FileContent: () => FileContent2,
+  ListEntry: () => ListEntry2,
+  ListPage: () => ListPage2,
+  MAX_MEDIA_INGEST_BYTES: () => MAX_MEDIA_INGEST_BYTES2,
+  MAX_READ_BYTES: () => MAX_READ_BYTES2,
+  MAX_READ_LINES: () => MAX_READ_LINES2,
+  MEDIA_MIMES: () => MEDIA_MIMES2,
+  MediaIngestLimitError: () => MediaIngestLimitError2,
+  OffsetOutOfRangeError: () => OffsetOutOfRangeError2,
+  PageInput: () => PageInput2,
+  PathKindError: () => PathKindError2,
   ReadToolFileSystem: () => exports_read_filesystem,
-  Service: () => Service,
-  TextPage: () => TextPage,
-  node: () => node,
-  read: () => read
+  Service: () => Service5,
+  TextPage: () => TextPage2,
+  node: () => node7,
+  read: () => read2
 });
 import path from "path";
 import { pathToFileURL } from "url";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";
 import { lookup } from "mime-types";
-var MAX_READ_LINES = 2000;
-var MAX_READ_BYTES = 50 * 1024;
-var MAX_MEDIA_INGEST_BYTES = 20 * 1024 * 1024;
+var MAX_READ_LINES2 = 2000;
+var MAX_READ_BYTES2 = 50 * 1024;
+var MAX_MEDIA_INGEST_BYTES2 = 20 * 1024 * 1024;
 var FIRST_CHUNK = 256 * 1024;
 var MAX_LINE_LENGTH = 2000;
 var TREE_BASE = 6;
 var MAX_LINE_SUFFIX = `... (line truncated to ${MAX_LINE_LENGTH} chars)`;
-var MEDIA_MIMES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp", "application/pdf"]);
+var MEDIA_MIMES2 = new Set(["image/png", "image/jpeg", "image/gif", "image/webp", "application/pdf"]);
 
-class BinaryFileError extends Schema.TaggedError()("ReadTool.BinaryFileError", {
+class BinaryFileError2 extends Schema.TaggedError()("ReadTool.BinaryFileError", {
   resource: Schema.String
 }) {
   get message() {
@@ -59,7 +60,7 @@ class BinaryFileError extends Schema.TaggedError()("ReadTool.BinaryFileError", {
   }
 }
 
-class MediaIngestLimitError extends Schema.TaggedError()("ReadTool.MediaIngestLimitError", {
+class MediaIngestLimitError2 extends Schema.TaggedError()("ReadTool.MediaIngestLimitError", {
   resource: Schema.String,
   maximumBytes: Schema.Number
 }) {
@@ -68,13 +69,13 @@ class MediaIngestLimitError extends Schema.TaggedError()("ReadTool.MediaIngestLi
   }
 }
 
-class OffsetOutOfRangeError extends Schema.TaggedError()("ReadTool.OffsetOutOfRangeError", { offset: Schema.Number }) {
+class OffsetOutOfRangeError2 extends Schema.TaggedError()("ReadTool.OffsetOutOfRangeError", { offset: Schema.Number }) {
   get message() {
     return `Offset ${this.offset} is out of range`;
   }
 }
 
-class PathKindError extends Schema.TaggedError()("ReadTool.PathKindError", {
+class PathKindError2 extends Schema.TaggedError()("ReadTool.PathKindError", {
   resource: Schema.String,
   expected: Schema.Literals(["a file", "a file or directory"])
 }) {
@@ -82,52 +83,52 @@ class PathKindError extends Schema.TaggedError()("ReadTool.PathKindError", {
     return `Path is not ${this.expected}: ${this.resource}`;
   }
 }
-var PageInput = Schema.Struct({
-  offset: Schema.optionalKey(NonNegativeInt),
-  limit: Schema.optionalKey(NonNegativeInt.check(Schema.isLessThanOrEqualTo(MAX_READ_LINES)))
+var PageInput2 = Schema.Struct({
+  offset: Schema.optionalKey(NonNegativeInt2),
+  limit: Schema.optionalKey(NonNegativeInt2.check(Schema.isLessThanOrEqualTo(MAX_READ_LINES2)))
 });
-var FileContent = Schema.Struct({
+var FileContent2 = Schema.Struct({
   type: Schema.Literal("file"),
-  ...exports_filesystem.Content.fields
+  ...Content3.fields
 }).annotate({ identifier: "ReadTool.FileContent" });
 
-class TextPage extends Schema.Class("ReadTool.TextPage")({
+class TextPage2 extends Schema.Class("ReadTool.TextPage")({
   type: Schema.Literal("text-page"),
   content: Schema.String,
   mime: Schema.String,
-  offset: PositiveInt,
+  offset: PositiveInt2,
   truncated: Schema.Boolean,
-  next: Schema.optionalKey(PositiveInt)
+  next: Schema.optionalKey(PositiveInt2)
 }) {
 }
-var ListEntry = Schema.Struct({
-  path: RelativePath,
+var ListEntry2 = Schema.Struct({
+  path: RelativePath2,
   type: Schema.Literals(["file", "directory", "symlink"])
 }).annotate({ identifier: "ReadTool.ListEntry" });
 
-class ListPage extends Schema.Class("ReadTool.ListPage")({
+class ListPage2 extends Schema.Class("ReadTool.ListPage")({
   type: Schema.Literal("list-page"),
-  entries: Schema.Array(ListEntry),
+  entries: Schema.Array(ListEntry2),
   truncated: Schema.Boolean,
-  next: Schema.optionalKey(PositiveInt)
+  next: Schema.optionalKey(PositiveInt2)
 }) {
 }
 
-class Service extends Context.Service()("@opencode/ReadToolFileSystem") {
+class Service5 extends Context.Service()("@opencode/ReadToolFileSystem") {
 }
 var mimeType = (value) => lookup(value) || "application/octet-stream";
-var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page = {}) {
+var read2 = Effect.fn("ReadTool.read")(function* (files, input, resource, page = {}) {
   const first = yield* files.read(input, { offset: 0, length: FIRST_CHUNK }).pipe(Effect.catchTag("Environment.WrongKind", (error) => {
     if (error.actual !== "directory")
-      return Effect.fail(new PathKindError({ resource, expected: "a file or directory" }));
-    return files.list(input).pipe(Effect.map((entries) => list(entries, page)), Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError({ resource, expected: "a file or directory" }))));
+      return Effect.fail(new PathKindError2({ resource, expected: "a file or directory" }));
+    return files.list(input).pipe(Effect.map((entries) => list(entries, page)), Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError2({ resource, expected: "a file or directory" }))));
   }));
-  if (first instanceof ListPage)
+  if (first instanceof ListPage2)
     return first;
-  const media = exports_mime.detect(first.bytes);
-  if (MEDIA_MIMES.has(media)) {
-    if (first.info.size > MAX_MEDIA_INGEST_BYTES)
-      return yield* new MediaIngestLimitError({ resource, maximumBytes: MAX_MEDIA_INGEST_BYTES });
+  const media = detect2(first.bytes);
+  if (MEDIA_MIMES2.has(media)) {
+    if (first.info.size > MAX_MEDIA_INGEST_BYTES2)
+      return yield* new MediaIngestLimitError2({ resource, maximumBytes: MAX_MEDIA_INGEST_BYTES2 });
     const whole = yield* readFile(files, input, resource);
     return {
       type: "file",
@@ -138,10 +139,10 @@ var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page =
       mime: media
     };
   }
-  const paged = first.info.size > MAX_READ_BYTES || page.offset !== undefined || page.limit !== undefined;
+  const paged = first.info.size > MAX_READ_BYTES2 || page.offset !== undefined || page.limit !== undefined;
   if (!paged) {
     if (first.bytes.includes(0))
-      return yield* new BinaryFileError({ resource });
+      return yield* new BinaryFileError2({ resource });
     return {
       type: "file",
       uri: pathToFileURL(input).href,
@@ -158,7 +159,7 @@ var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page =
     return yield* makeTextPage(input, resource, result, first.bytes.subarray(0, result.consumed).includes(0));
   }
   const offset = page.offset || 1;
-  const limit = Math.min(page.limit || MAX_READ_LINES, MAX_READ_LINES);
+  const limit = Math.min(page.limit || MAX_READ_LINES2, MAX_READ_LINES2);
   const leaves = [textLeaf(first.bytes)];
   let bytes = first.bytes.length;
   let lines = leaves[0].summary.lines;
@@ -169,12 +170,12 @@ var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page =
       const tree = textTree(leaves);
       const start = textOffset(tree, offset - 1);
       let position = 0;
-      const selected = Buffer.concat(leaves.flatMap((leaf2) => {
+      const selected = Buffer.concat(leaves.flatMap((leaf) => {
         const leafStart = position;
-        position += leaf2.summary.bytes;
+        position += leaf.summary.bytes;
         if (position <= start)
           return [];
-        return [leaf2.bytes.subarray(Math.max(0, start - leafStart))];
+        return [leaf.bytes.subarray(Math.max(0, start - leafStart))];
       }));
       const result = textPage(selected, eof, { limit });
       if (result !== undefined) {
@@ -185,10 +186,10 @@ var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page =
         };
         const consumed = start + result.consumed;
         let checked = 0;
-        const binary = leaves.some((leaf2) => {
-          const length = Math.min(leaf2.summary.bytes, consumed - checked);
-          checked += leaf2.summary.bytes;
-          return length > 0 && leaf2.bytes.subarray(0, length).includes(0);
+        const binary = leaves.some((leaf) => {
+          const length = Math.min(leaf.summary.bytes, consumed - checked);
+          checked += leaf.summary.bytes;
+          return length > 0 && leaf.bytes.subarray(0, length).includes(0);
         });
         return yield* makeTextPage(input, resource, translated, binary);
       }
@@ -204,13 +205,13 @@ var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page =
     lines += leaf.summary.lines;
   }
 });
-var readFile = (files, input, resource, range) => files.read(input, range).pipe(Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError({ resource, expected: "a file" }))));
+var readFile = (files, input, resource, range) => files.read(input, range).pipe(Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError2({ resource, expected: "a file" }))));
 var makeTextPage = Effect.fnUntraced(function* (input, resource, result, binary) {
   if (binary)
-    return yield* new BinaryFileError({ resource });
+    return yield* new BinaryFileError2({ resource });
   if (result.entries.length === 0 && result.offset !== 1)
-    return yield* new OffsetOutOfRangeError({ offset: result.offset });
-  return new TextPage({
+    return yield* new OffsetOutOfRangeError2({ offset: result.offset });
+  return new TextPage2({
     type: "text-page",
     content: result.entries.join(`
 `),
@@ -222,16 +223,16 @@ var makeTextPage = Effect.fnUntraced(function* (input, resource, result, binary)
 });
 var list = (items, page) => {
   const offset = page.offset || 1;
-  const limit = Math.min(page.limit || MAX_READ_LINES, MAX_READ_LINES);
+  const limit = Math.min(page.limit || MAX_READ_LINES2, MAX_READ_LINES2);
   const visible = items.flatMap((item) => item.type === "other" ? [] : [
-    ListEntry.make({
-      path: RelativePath.make(item.name + (item.type === "directory" ? path.sep : "")),
+    ListEntry2.make({
+      path: RelativePath2.make(item.name + (item.type === "directory" ? path.sep : "")),
       type: item.type
     })
   ]).sort((a, b) => a.type === "directory" ? b.type === "directory" ? a.path.localeCompare(b.path) : -1 : b.type === "directory" ? 1 : a.path.localeCompare(b.path));
   const selected = visible.slice(offset - 1, offset - 1 + limit);
   const truncated = offset - 1 + selected.length < visible.length;
-  return new ListPage({
+  return new ListPage2({
     type: "list-page",
     entries: selected,
     truncated,
@@ -240,7 +241,7 @@ var list = (items, page) => {
 };
 var textPage = (bytes, eof, page) => {
   const offset = page.offset || 1;
-  const limit = Math.min(page.limit || MAX_READ_LINES, MAX_READ_LINES);
+  const limit = Math.min(page.limit || MAX_READ_LINES2, MAX_READ_LINES2);
   const decoded = new TextDecoder().decode(bytes);
   const split = decoded.split(`
 `);
@@ -251,13 +252,13 @@ var textPage = (bytes, eof, page) => {
   let next;
   for (const [index, value] of available.slice(offset - 1).entries()) {
     const line = offset + index;
-    if (entries.length >= limit || size >= MAX_READ_BYTES) {
+    if (entries.length >= limit || size >= MAX_READ_BYTES2) {
       next = line;
       break;
     }
     const text = value.length > MAX_LINE_LENGTH ? value.slice(0, MAX_LINE_LENGTH) + MAX_LINE_SUFFIX : value;
     const lineSize = Buffer.byteLength(text, "utf-8") + (entries.length > 0 ? 1 : 0);
-    if (size + lineSize > MAX_READ_BYTES) {
+    if (size + lineSize > MAX_READ_BYTES2) {
       next = line;
       break;
     }
@@ -325,13 +326,13 @@ var nthNewline = (bytes, count) => {
       return index + 1;
   }
 };
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const environment = yield* exports_environment.Service;
-  return Service.of({
+var layer = Layer.effect(Service5, Effect.gen(function* () {
+  const environment = yield* Service62;
+  return Service5.of({
     list: environment.files.list,
-    read: (path2, resource, page) => read(environment.files, path2, resource, page)
+    read: (path2, resource, page) => read2(environment.files, path2, resource, page)
   });
 }));
-var node = makeLocationNode({ service: Service, layer, deps: [exports_environment.node] });
+var node7 = makeLocationNode({ service: Service5, layer, deps: [node65] });
 
-export { MAX_READ_LINES, MAX_READ_BYTES, MAX_MEDIA_INGEST_BYTES, MEDIA_MIMES, BinaryFileError, MediaIngestLimitError, OffsetOutOfRangeError, PathKindError, PageInput, FileContent, TextPage, ListEntry, ListPage, Service, read, node, exports_read_filesystem };
+export { MAX_READ_LINES2, MAX_READ_BYTES2, MAX_MEDIA_INGEST_BYTES2, MEDIA_MIMES2, BinaryFileError2, MediaIngestLimitError2, OffsetOutOfRangeError2, PathKindError2, PageInput2, FileContent2, TextPage2, ListEntry2, ListPage2, Service5, read2, node7, exports_read_filesystem };

package/dist/chunks/{instance-1nnvw04n.js → kv-8fjpabk1.js}

@@ -1,74 +1,80 @@
 import {
-  exports_instructions
-} from "./instance-c54e84vp.js";
+  ephemeral2,
+  Service79,
+  node83
+} from "./kv-9j3fyze8.js";
 import {
-  exports_state
-} from "./instance-j6s3yjyb.js";
+  Key3,
+  unavailable3,
+  removed2,
+  make19,
+  diffByKey2
+} from "./kv-6e958v7x.js";
 import {
-  AbsolutePath
-} from "./instance-j07kk359.js";
+  AbsolutePath2
+} from "./kv-p8qxwesx.js";
 import {
-  exports_bus
-} from "./instance-3dwd52hd.js";
+  create3
+} from "./kv-kg06axw8.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/instruction-discovery.ts
 var exports_instruction_discovery = {};
 __export(exports_instruction_discovery, {
-  Event: () => Event,
-  File: () => File,
+  Event: () => Event6,
+  File: () => File2,
   InstructionDiscovery: () => exports_instruction_discovery,
-  Options: () => Options,
-  Service: () => Service,
-  configured: () => configured,
-  layer: () => layer,
-  node: () => node
+  Options: () => Options4,
+  Service: () => Service41,
+  configured: () => configured4,
+  layer: () => layer17,
+  node: () => node43
 });
 import { Context, Effect, Layer, Schema } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { createPatch } from "diff";
-class File extends Schema.Class("InstructionDiscovery.File")({
-  path: AbsolutePath,
+class File2 extends Schema.Class("InstructionDiscovery.File")({
+  path: AbsolutePath2,
   content: Schema.String
 }) {
 }
-var Files = Schema.Array(File);
-var key = exports_instructions.Key.make("core/instructions");
-var Event = {
-  Updated: exports_bus.ephemeral({ type: "instruction-discovery.updated", schema: {} })
+var Files = Schema.Array(File2);
+var key = Key3.make("core/instructions");
+var Event6 = {
+  Updated: ephemeral2({ type: "instruction-discovery.updated", schema: {} })
 };
-var Options = Schema.Struct({
+var Options4 = Schema.Struct({
   project: Schema.optional(Schema.Boolean),
   global: Schema.optional(Schema.Boolean)
 });
 
-class Service extends Context.Service()("@opencode/InstructionDiscovery") {
+class Service41 extends Context.Service()("@opencode/InstructionDiscovery") {
 }
-var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
-  const bus = yield* exports_bus.Service;
-  const state = exports_state.create({
+var layer17 = (options) => Layer.effect(Service41, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const state = create3({
     name: "instruction-discovery",
     initial: () => ({ files: new Map, available: true }),
     editor: (editor) => ({
       list: () => Array.from(editor.files.values()),
-      add: (file) => editor.files.set(file.path, new File(file)),
+      add: (file) => editor.files.set(file.path, new File2(file)),
       update: (path, update) => {
-        const current = editor.files.get(AbsolutePath.make(path));
+        const current = editor.files.get(AbsolutePath2.make(path));
         if (!current)
           return;
         update(current);
-        current.path = AbsolutePath.make(path);
+        current.path = AbsolutePath2.make(path);
       },
-      remove: (path) => editor.files.delete(AbsolutePath.make(path)),
+      remove: (path) => editor.files.delete(AbsolutePath2.make(path)),
       unavailable: () => {
         editor.available = false;
       }
     }),
-    notify: () => bus.publish(Event.Updated, {}).pipe(Effect.asVoid)
+    notify: () => bus.publish(Event6.Updated, {}).pipe(Effect.asVoid)
   });
-  const source = (value) => exports_instructions.make({
+  const source = (value) => make19({
     key,
     codec: Schema.toCodecJson(Files),
     read: Effect.succeed(value),
@@ -81,10 +87,10 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
   const list = Effect.fn("InstructionDiscovery.list")(function* () {
     const current = state.get();
     if (!current.available)
-      return exports_instructions.unavailable;
+      return unavailable3;
     return Array.from(current.files.values());
   });
-  return Service.of({
+  return Service41.of({
     project: options?.project !== false,
     global: options?.global !== false,
     transform: state.transform,
@@ -94,18 +100,18 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
       const files = yield* list();
       if (!Array.isArray(files))
         return source(files);
-      return source(files.length === 0 ? exports_instructions.removed : files);
+      return source(files.length === 0 ? removed2 : files);
     })
   });
 }));
-function configured(options) {
+function configured4(options) {
   return makeLocationNode({
-    service: Service,
-    layer: layer(options),
-    deps: [exports_bus.node]
+    service: Service41,
+    layer: layer17(options),
+    deps: [node83]
   });
 }
-var node = configured();
+var node43 = configured4();
 function render(files) {
   return files.map((file) => `Instructions from: ${file.path}
 ${file.content}`).join(`
@@ -113,7 +119,7 @@ ${file.content}`).join(`
 `);
 }
 function renderUpdate(previous, current) {
-  const changes = exports_instructions.diffByKey(previous, current, (file) => file.path, (before, after) => before.content !== after.content);
+  const changes = diffByKey2(previous, current, (file) => file.path, (before, after) => before.content !== after.content);
   return [
     ...changes.removed.map((file) => `The instructions from ${file.path} no longer apply.`),
     ...changes.added.map((file) => `New instructions apply from:
@@ -136,4 +142,4 @@ ${render([after])}`;
 `);
 }
 
-export { File, Event, Options, Service, layer, configured, node, exports_instruction_discovery };
+export { File2, Event6, Options4, Service41, layer17, configured4, node43, exports_instruction_discovery };

package/dist/chunks/{instance-zn935gjz.js → kv-8npyp30c.js}

@@ -1,22 +1,22 @@
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/session/environment.ts
 var exports_environment = {};
 __export(exports_environment, {
-  Service: () => Service,
+  Service: () => Service39,
   SessionEnvironment: () => exports_environment,
-  node: () => node
+  node: () => node41
 });
 import { Context, Effect, Layer } from "effect";
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
 
-class Service extends Context.Service()("@opencode/SessionEnvironment") {
+class Service39 extends Context.Service()("@opencode/SessionEnvironment") {
 }
-var layer = Layer.sync(Service, () => {
+var layer = Layer.sync(Service39, () => {
   const environments = new Map;
-  return Service.of({
+  return Service39.of({
     get: (sessionID) => Effect.sync(() => environments.get(sessionID)),
     set: (sessionID, variables) => Effect.sync(() => {
       environments.set(sessionID, { ...variables });
@@ -26,6 +26,6 @@ var layer = Layer.sync(Service, () => {
     })
   });
 });
-var node = makeGlobalNode({ service: Service, layer, deps: [] });
+var node41 = makeGlobalNode({ service: Service39, layer, deps: [] });
 
-export { Service, node, exports_environment };
+export { Service39, node41, exports_environment };

package/dist/chunks/{instance-6hppa3xw.js → kv-8s5g27jy.js}

@@ -1,16 +1,16 @@
 import {
-  AbsolutePath
-} from "./instance-j07kk359.js";
+  AbsolutePath2
+} from "./kv-p8qxwesx.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/skill/discovery.ts
 var exports_discovery = {};
 __export(exports_discovery, {
-  Service: () => Service,
+  Service: () => Service7,
   SkillDiscovery: () => exports_discovery,
-  node: () => node
+  node: () => node9
 });
 import path from "path";
 import { Context, Effect, Layer, Schedule, Schema } from "effect";
@@ -48,9 +48,9 @@ class Index extends Schema.Class("SkillDiscovery.Index")({
 }) {
 }
 
-class Service extends Context.Service()("@opencode/SkillDiscovery") {
+class Service7 extends Context.Service()("@opencode/SkillDiscovery") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service7, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
   const global = yield* Global.Service;
   const http = (yield* HttpClient.HttpClient).pipe(HttpClient.retryTransient({
@@ -63,7 +63,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       return true;
     return yield* HttpClientRequest.get(url).pipe(http.execute, Effect.flatMap((response) => response.arrayBuffer), Effect.flatMap((body) => fs.writeWithDirs(destination, new Uint8Array(body))), Effect.as(true), Effect.catch((error) => Effect.logError("failed to download skill file", { url, error }).pipe(Effect.as(false))));
   });
-  return Service.of({
+  return Service7.of({
     pull: Effect.fn("SkillDiscovery.pull")(function* (url) {
       const base = url.endsWith("/") ? url : `${url}/`;
       const source = new URL(base);
@@ -126,8 +126,8 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
             const downloaded = yield* Effect.forEach(files, (file) => download(file.url, path.resolve(staging, file.file)), { concurrency: fileConcurrency });
             if (!downloaded.every(Boolean))
               return;
-            const exists2 = (yield* fs.exists(path.join(staging, "SKILL.md")).pipe(Effect.orDie)) || (yield* fs.exists(path.join(staging, `${skill.name}.md`)).pipe(Effect.orDie));
-            if (!exists2)
+            const exists = (yield* fs.exists(path.join(staging, "SKILL.md")).pipe(Effect.orDie)) || (yield* fs.exists(path.join(staging, `${skill.name}.md`)).pipe(Effect.orDie));
+            if (!exists)
               return;
             yield* fs.writeFileString(path.join(staging, ".opencode-version"), version);
             yield* Effect.uninterruptible(Effect.gen(function* () {
@@ -145,11 +145,11 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           }).pipe(Effect.catch((error) => Effect.logError("failed to refresh skill", { skill: skill.name, error })), Effect.ensuring(fs.remove(staging, { recursive: true, force: true }).pipe(Effect.ignore)));
         }
         const exists = (yield* fs.exists(path.join(root, "SKILL.md")).pipe(Effect.orDie)) || (yield* fs.exists(path.join(root, `${skill.name}.md`)).pipe(Effect.orDie));
-        return exists ? [AbsolutePath.make(root)] : [];
+        return exists ? [AbsolutePath2.make(root)] : [];
       }), { concurrency: skillConcurrency }).pipe(Effect.map((directories) => directories.flat()));
     })
   });
 }));
-var node = makeGlobalNode({ service: Service, layer, deps: [httpClient, FSUtil.node, Global.node] });
+var node9 = makeGlobalNode({ service: Service7, layer, deps: [httpClient, FSUtil.node, Global.node] });
 
-export { Service, node, exports_discovery };
+export { Service7, node9, exports_discovery };