@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-j4g5a3vz.js

@@ -0,0 +1,117 @@
+import {
+  exports_tool
+} from "./ripgrep-dxqw5jns.js";
+import {
+  exports_mcp
+} from "./ripgrep-f37844cq.js";
+import {
+  exports_permission
+} from "./ripgrep-x5r76fqd.js";
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/tool/mcp.ts
+var exports_mcp2 = {};
+__export(exports_mcp2, {
+  node: () => node,
+  namespace: () => namespace,
+  name: () => name,
+  layer: () => layer,
+  Service: () => Service,
+  McpTool: () => exports_mcp2
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { McpEvent } from "@opencode-ai/schema/mcp-event";
+import { Context, Effect, Exit, Fiber, Layer, Scope, Semaphore, Stream } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+var namespace = (server) => server.replace(/[^a-zA-Z0-9_-]/g, "_");
+var name = (server, tool) => `${namespace(server)}_${tool.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+
+class Service extends Context.Service()("@opencode/McpTool") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const mcp = yield* exports_mcp.Service;
+  const tools = yield* exports_tool.Service;
+  const bus = yield* exports_bus.Service;
+  const permission = yield* exports_permission.Service;
+  const scope = yield* Scope.Scope;
+  const lock = Semaphore.makeUnsafe(1);
+  let current;
+  const reconcile = lock.withPermit(Effect.gen(function* () {
+    const discovered = yield* mcp.tools();
+    const next = yield* Scope.fork(scope);
+    yield* tools.transform((draft) => {
+      for (const tool of discovered) {
+        const schema = tool.inputSchema ?? {};
+        draft.add({
+          name: tool.name,
+          options: { namespace: namespace(tool.server), codemode: tool.codemode !== false },
+          description: tool.description ?? "",
+          input: {
+            ...schema,
+            type: "object",
+            properties: schema.properties ?? {},
+            additionalProperties: false
+          },
+          output: tool.outputSchema ?? {},
+          execute: (input, context) => Effect.gen(function* () {
+            yield* permission.assert({
+              action: name(tool.server, tool.name),
+              resources: ["*"],
+              save: ["*"],
+              metadata: {},
+              sessionID: context.sessionID,
+              agent: context.agent,
+              source: {
+                type: "tool",
+                messageID: context.messageID,
+                id: context.id
+              }
+            });
+            const result = yield* mcp.callTool({
+              server: tool.server,
+              name: tool.name,
+              args: input ?? {}
+            }).pipe(Effect.catchTags({
+              "MCP.NotFoundError": (error) => new ToolFailure({ message: `MCP server "${error.server}" is not available` }),
+              "MCP.ToolCallError": (error) => new ToolFailure({ message: error.message })
+            }));
+            if (result.isError)
+              return yield* new ToolFailure({
+                message: result.content.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+`).trim() || "MCP tool returned an error"
+              });
+            const content = result.content.map((part) => part.type === "text" ? { type: "text", text: part.text } : {
+              type: "file",
+              uri: `data:${part.mimeType};base64,${part.data}`,
+              mime: part.mimeType
+            });
+            const text = content.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+`);
+            return {
+              output: result.structured ?? (text === "" ? null : text),
+              ...content.length === 0 ? {} : { content }
+            };
+          }).pipe(Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to execute ${name(tool.server, tool.name)}` })))
+        });
+      }
+    }).pipe(Scope.provide(next), Effect.orDie);
+    if (current)
+      yield* Scope.close(current, Exit.void);
+    current = next;
+  }));
+  const initial = yield* reconcile.pipe(Effect.forkScoped);
+  yield* bus.subscribe(McpEvent.ToolsChanged).pipe(Stream.runForEach(() => reconcile), Effect.forkScoped({ startImmediately: true }));
+  return Service.of({ flush: Effect.asVoid(Fiber.await(initial)) });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_tool.node, exports_mcp.node, exports_bus.node, exports_permission.node]
+});
+
+export { namespace, name, Service, layer, node, exports_mcp2 as exports_mcp };

package/dist/chunks/ripgrep-j4q10g9p.js

@@ -0,0 +1,87 @@
+import {
+  exports_skill
+} from "./ripgrep-p5bd5gkc.js";
+import {
+  exports_permission
+} from "./ripgrep-x5r76fqd.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/tool/plugin/skill.ts
+var exports_skill2 = {};
+__export(exports_skill2, {
+  toModelOutput: () => toModelOutput,
+  name: () => name,
+  description: () => description,
+  SkillTool: () => exports_skill2,
+  Plugin: () => Plugin,
+  Output: () => Output,
+  Input: () => Input
+});
+import path from "path";
+import { ToolFailure } from "@opencode-ai/ai";
+import { Effect, Schema } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+var name = "skill";
+var FILE_LIMIT = 10;
+var Input = Schema.Struct({
+  id: exports_skill.ID.annotate({ description: "The ID of the skill from the available skills list" })
+});
+var Output = Schema.Struct({
+  name: exports_skill.Name,
+  directory: Schema.String,
+  output: Schema.String
+});
+var description = [
+  "Load a specialized skill's instructions and resources into the current conversation when the task at hand matches its description.",
+  "",
+  "The skill ID must match one of the available skills in the instructions."
+].join(`
+`);
+var toModelOutput = exports_skill.toModelOutput;
+var unableToLoad = (name2, error) => new ToolFailure({ message: `Unable to load skill ${name2}`, error });
+var Plugin = {
+  id: "opencode.tool.skill",
+  effect: Effect.fn("SkillTool.Plugin")(function* (ctx) {
+    const fs = yield* FSUtil.Service;
+    const skills = yield* exports_skill.Service;
+    const permission = yield* exports_permission.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false },
+      description,
+      input: Input,
+      output: Output,
+      execute: (input, context) => Effect.gen(function* () {
+        const current = yield* skills.list();
+        const skill = current.find((skill2) => skill2.id === input.id);
+        if (!skill)
+          return yield* unableToLoad(input.id);
+        return yield* Effect.gen(function* () {
+          yield* permission.assert({
+            action: name,
+            resources: [skill.id],
+            save: [skill.id],
+            sessionID: context.sessionID,
+            agent: context.agent,
+            source: { type: "tool", messageID: context.messageID, id: context.id }
+          });
+          const directory = path.dirname(skill.location);
+          const files = path.basename(skill.location) === "SKILL.md" ? (yield* fs.scan("**/*", { cwd: directory, absolute: true, include: "file", dot: true })).filter((file) => path.basename(file) !== "SKILL.md").toSorted().slice(0, FILE_LIMIT) : [];
+          return {
+            name: skill.name,
+            directory,
+            output: exports_skill.toModelOutput(skill, files)
+          };
+        }).pipe(Effect.mapError((error) => unableToLoad(input.id, error)));
+      }).pipe(Effect.map((output) => ({
+        output,
+        content: output.output,
+        metadata: { name: output.name, directory: output.directory }
+      })))
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name, Input, Output, description, toModelOutput, Plugin, exports_skill2 as exports_skill };

package/dist/chunks/ripgrep-jd2xt95y.js

@@ -0,0 +1,115 @@
+import {
+  exports_snapshot
+} from "./ripgrep-6q3rd30y.js";
+import {
+  exports_message
+} from "./ripgrep-25pxtba7.js";
+import {
+  SessionMessageTable
+} from "./ripgrep-9d2xhdr4.js";
+import {
+  SessionEvent
+} from "./ripgrep-a83yvq99.js";
+import {
+  RelativePath
+} from "./ripgrep-j07kk359.js";
+import {
+  exports_schema
+} from "./ripgrep-y8rs54ne.js";
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  exports_database
+} from "./ripgrep-x7kx8910.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/session/revert.ts
+var exports_revert = {};
+__export(exports_revert, {
+  stage: () => stage,
+  commit: () => commit,
+  clear: () => clear,
+  SessionRevert: () => exports_revert,
+  MessageNotFoundError: () => MessageNotFoundError
+});
+import { and, asc, eq, gt } from "drizzle-orm";
+import { Effect, Schema } from "effect";
+class MessageNotFoundError extends Schema.TaggedErrorClass()("Session.MessageNotFoundError", {
+  sessionID: exports_schema.ID,
+  messageID: exports_message.ID
+}) {
+}
+var plan = Effect.fn("SessionRevert.plan")(function* (input) {
+  const db = (yield* exports_database.Service).db;
+  const boundary = yield* db.select({ seq: SessionMessageTable.seq }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, input.sessionID), eq(SessionMessageTable.id, input.messageID))).get().pipe(Effect.orDie);
+  if (!boundary)
+    return yield* new MessageNotFoundError(input);
+  const rows = yield* db.select().from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, input.sessionID), eq(SessionMessageTable.type, "assistant"), gt(SessionMessageTable.seq, boundary.seq))).orderBy(asc(SessionMessageTable.seq)).all().pipe(Effect.orDie);
+  const decode = Schema.decodeUnknownEffect(exports_message.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, exports_snapshot.ID.make(message.snapshot.start));
+  }
+  return files;
+});
+var stage = Effect.fn("SessionRevert.stage")(function* (input) {
+  const snapshot = yield* exports_snapshot.Service;
+  const bus = yield* exports_bus.Service;
+  const original = input.session.revert?.snapshot ? exports_snapshot.ID.make(input.session.revert.snapshot) : yield* snapshot.capture();
+  const next = yield* plan({ sessionID: input.session.id, messageID: input.messageID });
+  const restore = new Map;
+  if (original) {
+    for (const file of input.session.revert?.files ?? [])
+      restore.set(RelativePath.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(SessionEvent.RevertEvent.Staged, {
+    sessionID: input.session.id,
+    revert
+  });
+  return revert;
+});
+var clear = Effect.fn("SessionRevert.clear")(function* (session) {
+  if (!session.revert)
+    return;
+  const snapshot = yield* exports_snapshot.Service;
+  const original = session.revert.snapshot ? exports_snapshot.ID.make(session.revert.snapshot) : undefined;
+  if (original)
+    yield* snapshot.restore({
+      files: new Map((session.revert.files ?? []).map((file) => [RelativePath.make(file.file), original]))
+    });
+  const bus = yield* exports_bus.Service;
+  yield* bus.publish(SessionEvent.RevertEvent.Cleared, {
+    sessionID: session.id
+  });
+});
+var commit = Effect.fn("SessionRevert.commit")(function* (session) {
+  if (!session.revert)
+    return;
+  const bus = yield* exports_bus.Service;
+  yield* bus.publish(SessionEvent.RevertEvent.Committed, {
+    sessionID: session.id,
+    to: session.revert.messageID
+  });
+});
+
+export { MessageNotFoundError, stage, clear, commit, exports_revert };

package/dist/chunks/ripgrep-jssy2dr3.js

@@ -0,0 +1,18 @@
+import {
+  createProviderPlugin
+} from "./ripgrep-0zz82cjq.js";
+import {
+  __require
+} from "./ripgrep-rvfvac9x.js";
+
+// src/plugin/provider/togetherai.ts
+var TogetherAIPlugin = createProviderPlugin({
+  id: "opencode.provider.togetherai",
+  package: "@ai-sdk/togetherai",
+  load: async (options) => {
+    const { createTogetherAI } = await import("@ai-sdk/togetherai");
+    return createTogetherAI(options);
+  }
+});
+
+export { TogetherAIPlugin };

package/dist/chunks/ripgrep-jve7t217.js

@@ -0,0 +1,28 @@
+// src/tool/http-body.ts
+import { Effect, Stream } from "effect";
+var collectBoundedResponseBody = (response, maximumBytes, tooLarge) => Effect.gen(function* () {
+  const contentLength = response.headers["content-length"];
+  const parsedSize = contentLength ? Number.parseInt(contentLength, 10) : undefined;
+  const declaredSize = parsedSize !== undefined && Number.isSafeInteger(parsedSize) && parsedSize >= 0 ? parsedSize : undefined;
+  if (declaredSize !== undefined && declaredSize > maximumBytes)
+    return yield* Effect.fail(tooLarge());
+  let body = Buffer.allocUnsafe(Math.min(maximumBytes, declaredSize || 64 * 1024));
+  let size = 0;
+  yield* Stream.runForEach(response.stream, (chunk) => {
+    if (chunk.byteLength === 0)
+      return Effect.void;
+    if (size + chunk.byteLength > maximumBytes)
+      return Effect.fail(tooLarge());
+    if (size + chunk.byteLength > body.byteLength) {
+      const grown = Buffer.allocUnsafe(Math.min(maximumBytes, Math.max(size + chunk.byteLength, body.byteLength * 2)));
+      body.copy(grown, 0, 0, size);
+      body = grown;
+    }
+    body.set(chunk, size);
+    size += chunk.byteLength;
+    return Effect.void;
+  });
+  return body.subarray(0, size);
+});
+
+export { collectBoundedResponseBody };

package/dist/chunks/ripgrep-jzf304yt.js

@@ -0,0 +1,294 @@
+import {
+  exports_protected
+} from "./ripgrep-kg1345f7.js";
+import {
+  exports_ripgrep
+} from "./ripgrep-3kxbn56b.js";
+import {
+  exports_location
+} from "./ripgrep-hcyadm03.js";
+import {
+  PositiveInt,
+  RelativePath
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/filesystem/search.ts
+var exports_search = {};
+__export(exports_search, {
+  ripgrepLayer: () => ripgrepLayer,
+  node: () => node2,
+  layer: () => layer,
+  fffLayer: () => fffLayer,
+  configured: () => configured,
+  Service: () => Service2,
+  Options: () => Options,
+  FileSystemSearch: () => exports_search
+});
+import { makeLocationNode as makeLocationNode2 } from "@opencode-ai/util/effect/app-node";
+import path2 from "path";
+import { Clock, Context as Context2, Duration, Effect as Effect2, Layer as Layer2, Schema as Schema2, Scope } from "effect";
+import { Fff } from "#fff";
+import fuzzysort from "fuzzysort";
+
+// src/filesystem.ts
+var exports_filesystem = {};
+__export(exports_filesystem, {
+  node: () => node,
+  Submatch: () => Submatch,
+  Service: () => Service,
+  ReadInput: () => ReadInput,
+  Match: () => Match,
+  ListInput: () => ListInput,
+  GrepInput: () => GrepInput,
+  GlobInput: () => GlobInput,
+  FindInput: () => FindInput,
+  FileSystem: () => exports_filesystem,
+  Event: () => Event,
+  Entry: () => Entry2,
+  DEFAULT_SEARCH_TIMEOUT_MS: () => DEFAULT_SEARCH_TIMEOUT_MS,
+  DEFAULT_SEARCH_LIMIT: () => DEFAULT_SEARCH_LIMIT,
+  Content: () => Content
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import path from "path";
+import { Context, Effect, Layer, Schema } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Entry, FileSystem, FindInput } from "@opencode-ai/schema/filesystem";
+import { Entry as Entry2, Match, Submatch } from "@opencode-ai/schema/filesystem";
+var ReadInput = Schema.Struct({
+  path: RelativePath
+});
+var Content = Schema.Struct({
+  uri: Schema.String,
+  name: Schema.String.pipe(Schema.optional),
+  content: Schema.String,
+  encoding: Schema.Literals(["utf8", "base64"]),
+  mime: Schema.String
+}).annotate({ identifier: "FileSystem.Content" });
+var ListInput = Schema.Struct({
+  path: RelativePath.pipe(Schema.optional)
+});
+var DEFAULT_SEARCH_LIMIT = 100;
+var DEFAULT_SEARCH_TIMEOUT_MS = 30000;
+
+class GlobInput extends Schema.Class("FileSystem.GlobInput")({
+  pattern: Schema.String,
+  path: Schema.optionalKey(RelativePath),
+  limit: Schema.optionalKey(PositiveInt)
+}) {
+}
+
+class GrepInput extends Schema.Class("FileSystem.GrepInput")({
+  pattern: Schema.String,
+  path: Schema.optionalKey(RelativePath),
+  include: Schema.optionalKey(Schema.String),
+  limit: Schema.optionalKey(PositiveInt)
+}) {
+}
+var Event = FileSystem.Event;
+
+class Service extends Context.Service()("@opencode/FileSystem") {
+}
+var baseLayer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const location = yield* exports_location.Service;
+  const search = yield* exports_search.Service;
+  const root = yield* fs.realPath(location.directory).pipe(Effect.orDie);
+  const resolve = Effect.fnUntraced(function* (input) {
+    const absolute = path.resolve(location.directory, input ?? ".");
+    if (!FSUtil.contains(location.directory, absolute))
+      return yield* Effect.die(new Error("Path escapes the location"));
+    const real = yield* fs.realPath(absolute).pipe(Effect.orDie);
+    if (!FSUtil.contains(root, real))
+      return yield* Effect.die(new Error("Path escapes the location"));
+    return { absolute, real, directory: location.directory, root };
+  });
+  return Service.of({
+    find: search.find,
+    read: Effect.fn("FileSystem.read")(function* (input) {
+      const target = yield* resolve(input.path);
+      const info = yield* fs.stat(target.real).pipe(Effect.orDie);
+      if (info.type !== "File")
+        return yield* Effect.die(new Error("Path is not a file"));
+      return {
+        content: yield* fs.readFile(target.real).pipe(Effect.orDie),
+        mime: FSUtil.mimeType(target.real)
+      };
+    }),
+    list: Effect.fn("FileSystem.list")(function* (input = {}) {
+      const target = yield* resolve(input.path);
+      const info = yield* fs.stat(target.real).pipe(Effect.orDie);
+      if (info.type !== "Directory")
+        return yield* Effect.die(new Error("Path is not a directory"));
+      return yield* fs.readDirectoryEntries(target.real).pipe(Effect.orDie, Effect.map((items) => items.flatMap((item) => {
+        if (item.type !== "file" && item.type !== "directory")
+          return [];
+        const absolute = path.join(target.absolute, item.name);
+        const relative = path.relative(target.directory, absolute);
+        return [
+          Entry.make({
+            path: RelativePath.make(relative + (item.type === "directory" ? path.sep : "")),
+            type: item.type
+          })
+        ];
+      }).sort((a, b) => a.type === b.type ? a.path.localeCompare(b.path) : a.type === "directory" ? -1 : 1)));
+    })
+  });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer: baseLayer,
+  deps: [FSUtil.node, exports_location.node, exports_search.node]
+});
+
+// src/filesystem/search.ts
+var Options = Schema2.Struct({
+  fff: Schema2.optional(Schema2.Boolean)
+});
+
+class Service2 extends Context2.Service()("@opencode/FileSystem/Search") {
+}
+var REFRESH_INTERVAL = Duration.toMillis("10 seconds");
+function emptyIndex() {
+  return { files: new Map, directories: new Map };
+}
+function search(index, input) {
+  const items = input.type === "file" ? Array.from(index.files.values()) : input.type === "directory" ? Array.from(index.directories.values()) : [...index.files.values(), ...index.directories.values()];
+  const result = fuzzysort.go(input.query, items, { limit: input.limit ?? 50 });
+  fuzzysort.cleanup();
+  return result.map((item) => {
+    const relative = item.target;
+    const type = relative.endsWith(path2.sep) ? "directory" : "file";
+    return exports_filesystem.Entry.make({
+      path: RelativePath.make(relative),
+      type
+    });
+  });
+}
+var ripgrepLayer = Layer2.effect(Service2, Effect2.gen(function* () {
+  const location = yield* exports_location.Service;
+  const ripgrep = yield* exports_ripgrep.Service;
+  const scope = yield* Scope.Scope;
+  const clock = yield* Clock.Clock;
+  const home = exports_protected.isHome(location.directory);
+  let index = emptyIndex();
+  let initialized = false;
+  let settledAt = Number.NEGATIVE_INFINITY;
+  let refreshing = false;
+  const scan = Effect2.gen(function* () {
+    const next = emptyIndex();
+    const previous = index;
+    if (!initialized)
+      index = next;
+    yield* ripgrep.find({
+      cwd: location.directory,
+      pattern: "*",
+      limit: location.vcs && !home ? Number.MAX_SAFE_INTEGER : 1e5,
+      exclude: home ? [...exports_protected.names()].map((name) => `${name}/**`) : undefined,
+      onEntry: (entry) => Effect2.sync(() => {
+        next.files.set(entry.path, previous.files.get(entry.path) ?? fuzzysort.prepare(entry.path));
+        const parts = entry.path.split("/");
+        parts.slice(0, -1).forEach((_, offset) => {
+          const directory = parts.slice(0, offset + 1).join("/") + path2.sep;
+          if (!next.directories.has(directory))
+            next.directories.set(directory, previous.directories.get(directory) ?? fuzzysort.prepare(directory));
+        });
+      })
+    });
+    index = next;
+    initialized = true;
+  }).pipe(Effect2.orDie, Effect2.ensuring(Effect2.sync(() => {
+    settledAt = clock.currentTimeMillisUnsafe();
+    refreshing = false;
+  })));
+  const refresh = Effect2.sync(() => {
+    if (refreshing || clock.currentTimeMillisUnsafe() < settledAt + REFRESH_INTERVAL)
+      return;
+    refreshing = true;
+    return scan;
+  }).pipe(Effect2.flatMap((effect) => effect ? effect.pipe(Effect2.forkIn(scope)) : Effect2.void));
+  yield* refresh;
+  return Service2.of({
+    find: (input) => Effect2.gen(function* () {
+      yield* refresh;
+      return search(index, input);
+    })
+  });
+}));
+var fffLayer = Layer2.effect(Service2, Effect2.gen(function* () {
+  const location = yield* exports_location.Service;
+  const result = yield* Effect2.try({
+    try: () => Fff.create({
+      basePath: location.directory,
+      aiMode: true,
+      disableMmapCache: true,
+      disableContentIndexing: true
+    }),
+    catch: (cause) => cause
+  }).pipe(Effect2.catch((error) => Effect2.logWarning("failed to initialize fff", { error }).pipe(Effect2.as(undefined))));
+  if (!result?.ok) {
+    if (result)
+      yield* Effect2.logWarning("failed to initialize fff", { error: result.error });
+    return Service2.of({
+      find: () => Effect2.succeed([])
+    });
+  }
+  yield* Effect2.addFinalizer(() => Effect2.sync(() => result.value.destroy()).pipe(Effect2.ignore));
+  return Service2.of({
+    find: (input) => Effect2.sync(() => {
+      const options = { pageIndex: 0, pageSize: input.limit ?? 50 };
+      const items = (() => {
+        if (input.type === "file") {
+          const found2 = result.value.fileSearch(input.query.trim(), options);
+          if (!found2.ok)
+            throw found2.error;
+          return found2.value.items.map((item, index) => ({
+            path: item.relativePath,
+            type: "file",
+            score: found2.value.scores[index]?.total ?? 0
+          }));
+        }
+        if (input.type === "directory") {
+          const found2 = result.value.directorySearch(input.query.trim(), options);
+          if (!found2.ok)
+            throw found2.error;
+          return found2.value.items.map((item, index) => ({
+            path: item.relativePath,
+            type: "directory",
+            score: found2.value.scores[index]?.total ?? 0
+          }));
+        }
+        const found = result.value.mixedSearch(input.query.trim(), options);
+        if (!found.ok)
+          throw found.error;
+        return found.value.items.map((item, index) => ({
+          path: item.item.relativePath,
+          type: item.type,
+          score: found.value.scores[index]?.total ?? 0
+        }));
+      })();
+      return items.sort((a, b) => b.score - a.score || a.path.length - b.path.length).map((item) => {
+        const relative = item.path.replaceAll("\\", "/").replace(/\/$/, "");
+        return exports_filesystem.Entry.make({
+          path: RelativePath.make(relative + (item.type === "directory" ? path2.sep : "")),
+          type: item.type
+        });
+      });
+    })
+  });
+}));
+var layer = (options) => Layer2.unwrap(Effect2.gen(function* () {
+  if (options?.fff === false || options?.fff === undefined && process.platform === "win32" || !Fff.available())
+    return ripgrepLayer;
+  const location = yield* exports_location.Service;
+  return location.vcs && !exports_protected.isHome(location.directory) ? fffLayer : ripgrepLayer;
+}));
+function configured(options) {
+  return makeLocationNode2({ service: Service2, layer: layer(options), deps: [exports_location.node, exports_ripgrep.node] });
+}
+var node2 = configured();
+
+export { Options, Service2 as Service, ripgrepLayer, fffLayer, layer, configured, node2 as node, exports_search, FindInput, ReadInput, Content, ListInput, DEFAULT_SEARCH_LIMIT, DEFAULT_SEARCH_TIMEOUT_MS, GlobInput, GrepInput, Event, Service as Service1, node as node1, exports_filesystem, Entry2 as Entry, Match, Submatch };