@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-sk3qaz4a.js

@@ -0,0 +1,511 @@
+// src/persistent-pty/daemon.ts
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import net from "node:net";
+import path from "node:path";
+import { Data, Duration, Effect, Schema, Semaphore } from "effect";
+var ProtocolVersion = 7;
+var MaxFrameBytes = 8 * 1024 * 1024;
+var Lifecycle = Schema.Union([
+  Schema.Struct({ status: Schema.Literal("running") }),
+  Schema.Struct({ status: Schema.Literal("exited"), exit_code: Schema.NullOr(Schema.Number) }),
+  Schema.Struct({ status: Schema.Literal("failed"), message: Schema.String })
+]);
+var WireTerminal2 = Schema.Struct({
+  id: Schema.Number,
+  pid: Schema.NullOr(Schema.Number),
+  title: Schema.String,
+  foreground_process: Schema.NullOr(Schema.String),
+  group_id: Schema.String,
+  command: Schema.Array(Schema.String),
+  cwd: Schema.String,
+  cols: Schema.Number,
+  rows: Schema.Number,
+  lifecycle: Lifecycle,
+  output_head: Schema.Number,
+  output_tail: Schema.Number
+});
+var Registration = Schema.Struct({
+  instance_id: Schema.String,
+  pid: Schema.Number,
+  protocol: Schema.Number,
+  socket: Schema.String,
+  token: Schema.String
+});
+var WireResponse2 = Schema.Union([
+  Schema.Struct({
+    type: Schema.Literal("pong"),
+    instance_id: Schema.String,
+    pid: Schema.Number,
+    protocol: Schema.Number
+  }),
+  Schema.Struct({ type: Schema.Literal("created"), terminal: WireTerminal2 }),
+  Schema.Struct({ type: Schema.Literal("terminals"), terminals: Schema.Array(WireTerminal2) }),
+  Schema.Struct({ type: Schema.Literal("ok") }),
+  Schema.Struct({ type: Schema.Literal("owned") }),
+  Schema.Struct({ type: Schema.Literal("handoff"), ticket: Schema.String, expires_at: Schema.Number }),
+  Schema.Struct({
+    type: Schema.Literal("snapshot"),
+    terminal: WireTerminal2,
+    text: Schema.String,
+    checkpoint_base64: Schema.String,
+    cursor_x: Schema.Number,
+    cursor_y: Schema.Number
+  }),
+  Schema.Struct({
+    type: Schema.Literal("rows"),
+    terminal: WireTerminal2,
+    lines: Schema.Array(Schema.String),
+    cursor_x: Schema.Number,
+    cursor_y: Schema.Number
+  }),
+  Schema.Struct({
+    type: Schema.Literal("attached"),
+    terminal: WireTerminal2,
+    role: Schema.Literals(["controller", "observer"]),
+    generation: Schema.Number,
+    requested_offset: Schema.Number,
+    available_offset: Schema.Number,
+    end_offset: Schema.Number,
+    truncated: Schema.Boolean,
+    replay_base64: Schema.String
+  }),
+  Schema.Struct({
+    type: Schema.Literal("resized"),
+    cols: Schema.Number,
+    rows: Schema.Number,
+    generation: Schema.Number,
+    checkpoint_base64: Schema.String
+  }),
+  Schema.Struct({
+    type: Schema.Literal("exited"),
+    exit_code: Schema.NullOr(Schema.Number),
+    final_offset: Schema.Number
+  }),
+  Schema.Struct({
+    type: Schema.Literal("controller_changed"),
+    attachment_id: Schema.NullOr(Schema.String),
+    generation: Schema.Number
+  }),
+  Schema.Struct({ type: Schema.Literal("title_changed"), title: Schema.String }),
+  Schema.Struct({ type: Schema.Literal("foreground_process_changed"), process: Schema.NullOr(Schema.String) }),
+  Schema.Struct({ type: Schema.Literal("error"), message: Schema.String })
+]);
+
+class DaemonError2 extends Data.TaggedError("PersistentPty.DaemonError") {
+}
+var makeDaemonTransport2 = Effect.fn("PersistentPty.makeDaemonTransport")(function* (directory, binary = () => Promise.resolve(process.env.OPENCODE_PTY_BIN || "opencode-pty"), inherited) {
+  const startup = Semaphore.makeUnsafe(1);
+  let registration;
+  let owner;
+  let closed = false;
+  yield* Effect.addFinalizer(() => Effect.sync(() => {
+    closed = true;
+    owner?.socket.destroy();
+  }));
+  const claim = (current, ticket) => Effect.tryPromise({
+    try: async (signal) => {
+      const connection = await openOwner(current, ticket, signal);
+      if (closed || signal.aborted) {
+        connection.socket.destroy();
+        throw new Error("PTY owner scope is closed");
+      }
+      owner = connection;
+      registration = current;
+      connection.socket.once("close", () => {
+        if (owner !== connection)
+          return;
+        owner = undefined;
+        registration = undefined;
+      });
+    },
+    catch: (cause) => failure("connect", cause)
+  }).pipe(Effect.timeoutOrElse({
+    duration: Duration.seconds(5),
+    orElse: () => Effect.fail(new DaemonError2({ kind: "connect", message: "PTY ownership claim timed out" }))
+  }));
+  const discover = Effect.fn("PersistentPty.daemon.discover")(function* () {
+    const value = yield* Effect.tryPromise({
+      try: () => readFile(path.join(directory, "service.json"), "utf8"),
+      catch: (cause) => failure("connect", cause)
+    });
+    const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Registration))(value).pipe(Effect.mapError((cause) => failure("protocol", cause)));
+    if (decoded.protocol !== ProtocolVersion)
+      return yield* Effect.fail(new DaemonError2({
+        kind: "protocol",
+        message: `opencode-pty protocol mismatch: daemon=${decoded.protocol}, client=${ProtocolVersion}`,
+        pid: decoded.pid
+      }));
+    const response = yield* oneShot(decoded, { op: "ping" });
+    if (response.type !== "pong" || response.instance_id !== decoded.instance_id || response.pid !== decoded.pid || response.protocol !== ProtocolVersion)
+      return yield* Effect.fail(new DaemonError2({ kind: "protocol", message: "opencode-pty registration mismatch" }));
+    return decoded;
+  });
+  const start = Effect.fn("PersistentPty.daemon.start")(function* () {
+    const executable = yield* Effect.tryPromise({ try: binary, catch: (cause) => failure("spawn", cause) });
+    const child = yield* Effect.tryPromise({
+      try: () => new Promise((resolve, reject) => {
+        const child = spawn(executable, ["daemon"], {
+          detached: true,
+          stdio: "ignore",
+          env: { ...process.env, OPENCODE_PTY_RUNTIME_DIR: directory }
+        });
+        child.once("spawn", () => {
+          child.unref();
+          resolve(child);
+        });
+        child.once("error", reject);
+      }),
+      catch: (cause) => failure("spawn", cause)
+    });
+    return yield* Effect.gen(function* () {
+      const deadline = Date.now() + 5000;
+      let last;
+      while (Date.now() < deadline) {
+        const found = yield* discover().pipe(Effect.map((value) => ({ value })), Effect.catch((error) => {
+          last = error;
+          return Effect.succeed(undefined);
+        }));
+        if (found) {
+          yield* claim(found.value);
+          return found.value;
+        }
+        yield* Effect.sleep(50);
+      }
+      return yield* Effect.fail(last ?? new DaemonError2({ kind: "connect", message: "opencode-pty did not become ready" }));
+    }).pipe(Effect.onError(() => Effect.sync(() => {
+      child.kill("SIGTERM");
+    })));
+  });
+  const connect = Effect.fn("PersistentPty.daemon.connect")(function* (shouldStart) {
+    if (closed)
+      return yield* Effect.fail(new DaemonError2({ kind: "connect", message: "PTY owner scope is closed" }));
+    if (registration)
+      return registration;
+    return yield* startup.withPermit(Effect.gen(function* () {
+      if (registration)
+        return registration;
+      const found = yield* discover().pipe(Effect.catch((error) => {
+        if (shouldStart && error.kind === "connect")
+          return start();
+        return Effect.fail(error);
+      }));
+      if (!owner)
+        yield* claim(found);
+      registration = found;
+      return found;
+    }));
+  });
+  const attempt = Effect.fn("PersistentPty.daemon.request-attempt")(function* (value, shouldStart) {
+    const current = yield* connect(shouldStart);
+    return yield* oneShot(current, value).pipe(Effect.catch((error) => {
+      if (error.kind === "registration" && registration === current)
+        registration = undefined;
+      return Effect.fail(error);
+    }));
+  });
+  const request = Effect.fn("PersistentPty.daemon.request")(function* (value, shouldStart = false) {
+    return yield* attempt(value, shouldStart).pipe(Effect.catch((error) => {
+      if (error.kind === "registration")
+        return attempt(value, shouldStart);
+      if (error.kind !== "connect")
+        return Effect.fail(error);
+      registration = undefined;
+      if (!shouldStart)
+        return Effect.fail(error);
+      return attempt(value, true);
+    }));
+  });
+  const requestIfRunning = (value) => request(value).pipe(Effect.catch((error) => error.kind === "connect" ? Effect.succeed(undefined) : Effect.fail(error)));
+  const shutdown = Effect.gen(function* () {
+    const response = yield* requestIfRunning({ op: "shutdown" });
+    registration = undefined;
+    if (!response)
+      return;
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+      const running = yield* discover().pipe(Effect.as(true), Effect.orElseSucceed(() => false));
+      if (!running)
+        return response;
+      yield* Effect.sleep(50);
+    }
+    return yield* Effect.fail(new DaemonError2({ kind: "connect", message: "opencode-pty did not stop" }));
+  });
+  const handoff = startup.withPermit(Effect.gen(function* () {
+    const current = owner;
+    const registered = registration;
+    if (!current || !registered)
+      return null;
+    const response = yield* Effect.tryPromise({
+      try: (signal) => current.exchange({ op: "prepare_handoff" }, signal),
+      catch: (cause) => failure("response", cause)
+    }).pipe(Effect.timeoutOrElse({
+      duration: Duration.seconds(5),
+      orElse: () => Effect.fail(new DaemonError2({ kind: "response", message: "PTY handoff preparation timed out" }))
+    }));
+    if (response.type !== "handoff")
+      return yield* Effect.fail(new DaemonError2({ kind: "protocol", message: "Expected PTY handoff ticket" }));
+    return { directory, instanceID: registered.instance_id, ticket: response.ticket, expiresAt: response.expires_at };
+  }));
+  const subscribe = Effect.fn("PersistentPty.daemon.subscribe")(function* (id, input) {
+    const attempt = Effect.gen(function* () {
+      const current = yield* connect(false);
+      return yield* Effect.tryPromise({
+        try: () => subscribePromise(current, id, input),
+        catch: (cause) => cause instanceof DaemonError2 ? cause : failure("connect", cause)
+      }).pipe(Effect.catch((error) => {
+        if (error.kind === "registration" && registration === current)
+          registration = undefined;
+        return Effect.fail(error);
+      }));
+    });
+    return yield* attempt.pipe(Effect.catch((error) => error.kind === "registration" ? attempt : Effect.fail(error)));
+  });
+  if (inherited) {
+    if (inherited.expiresAt <= Date.now())
+      return yield* Effect.fail(new DaemonError2({ kind: "registration", message: "PTY restart handoff expired" }));
+    const current = yield* discover();
+    if (current.instance_id !== inherited.instanceID)
+      return yield* Effect.fail(new DaemonError2({ kind: "registration", message: "PTY restart daemon changed" }));
+    yield* claim(current, inherited.ticket);
+  }
+  return { request, requestIfRunning, shutdown, handoff, subscribe };
+});
+async function openOwner(registration, ticket, signal) {
+  const socket = net.createConnection({ path: registration.socket });
+  const frames = decoder(socket);
+  const abort = () => socket.destroy();
+  signal.addEventListener("abort", abort, { once: true });
+  const exchange = async (request, signal) => {
+    if (signal.aborted)
+      throw new Error("PTY ownership request interrupted");
+    signal.addEventListener("abort", abort, { once: true });
+    try {
+      socket.write(encode({ token: registration.token, request }));
+      const frame = await frames.next();
+      if (frame.done)
+        throw new Error("PTY daemon closed its ownership connection");
+      const response = decode(frame.value);
+      if (response.type === "error")
+        throw new Error(response.message);
+      return response;
+    } finally {
+      signal.removeEventListener("abort", abort);
+    }
+  };
+  try {
+    await new Promise((resolve, reject) => {
+      socket.once("connect", resolve);
+      socket.once("error", reject);
+      socket.once("close", () => reject(new Error("PTY ownership connection closed")));
+    });
+    const response = await exchange({ op: "own", instance_id: registration.instance_id, ticket }, signal);
+    if (response.type !== "owned")
+      throw new Error("PTY daemon does not support server ownership");
+    socket.unref();
+    return { socket, exchange };
+  } catch (error) {
+    socket.destroy();
+    throw error;
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
+var oneShot = Effect.fn("PersistentPty.daemon.oneShot")(function* (registration, request) {
+  const payload = yield* Effect.try({
+    try: () => encode({ token: registration.token, request }),
+    catch: (cause) => failure("protocol", cause)
+  });
+  let dispatched = false;
+  return yield* Effect.acquireUseRelease(Effect.tryPromise({
+    try: (signal) => new Promise((resolve, reject) => {
+      const socket = net.createConnection({ path: registration.socket, signal });
+      socket.once("connect", () => resolve(socket));
+      socket.once("error", reject);
+    }),
+    catch: (cause) => failure("connect", cause)
+  }), (socket) => Effect.gen(function* () {
+    yield* Effect.try({
+      try: () => {
+        dispatched = true;
+        socket.write(payload);
+      },
+      catch: (cause) => failure("response", cause)
+    });
+    const first = yield* Effect.tryPromise({
+      try: async (signal) => {
+        const frames = decoder(socket);
+        const abort = () => socket.destroy();
+        signal.addEventListener("abort", abort, { once: true });
+        try {
+          const frame = await frames.next();
+          if (frame.done)
+            throw new Error("opencode-pty closed without response");
+          return frame.value;
+        } finally {
+          signal.removeEventListener("abort", abort);
+        }
+      },
+      catch: (cause) => failure("response", cause)
+    });
+    const response = yield* Effect.try({
+      try: () => decode(first),
+      catch: (cause) => failure("protocol", cause)
+    });
+    if (response.type === "error")
+      return yield* Effect.fail(new DaemonError2({
+        kind: response.message === "authentication failed" ? "registration" : "protocol",
+        message: response.message
+      }));
+    return response;
+  }), (socket) => Effect.sync(() => socket.destroy())).pipe(Effect.timeoutOrElse({
+    duration: Duration.seconds(5),
+    orElse: () => Effect.fail(new DaemonError2({
+      kind: dispatched ? "response" : "connect",
+      message: "opencode-pty request timed out"
+    }))
+  }));
+});
+async function subscribePromise(registration, id, input) {
+  const socket = net.createConnection(registration.socket);
+  const frames = decoder(socket);
+  try {
+    await new Promise((resolve, reject) => {
+      socket.once("connect", resolve);
+      socket.once("error", reject);
+    });
+    socket.write(encode({
+      token: registration.token,
+      request: {
+        op: "subscribe",
+        id,
+        offset: input.cursor,
+        attachment_id: input.attachmentID,
+        role: input.role,
+        takeover: input.takeover ?? false
+      }
+    }));
+    const initial = await frames.next();
+    if (initial.done)
+      throw new Error("opencode-pty closed before attachment");
+    const response = decode(initial.value);
+    if (response.type === "error")
+      throw new DaemonError2({
+        kind: response.message === "authentication failed" ? "registration" : "protocol",
+        message: response.message
+      });
+    if (response.type !== "attached")
+      throw new Error(`unexpected opencode-pty response: ${response.type}`);
+    let detached = false;
+    const pump = async () => {
+      try {
+        for await (const frame of frames) {
+          if (frame[0] === 0) {
+            if (frame.length < 17)
+              throw new Error("invalid opencode-pty output frame");
+            input.onEvent({
+              type: "output",
+              start: Number(frame.readBigUInt64BE(1)),
+              end: Number(frame.readBigUInt64BE(9)),
+              data: frame.subarray(17)
+            });
+            continue;
+          }
+          const event = decode(frame);
+          if (event.type === "resized")
+            input.onEvent({
+              type: "resized",
+              cols: event.cols,
+              rows: event.rows,
+              generation: event.generation,
+              checkpoint: Buffer.from(event.checkpoint_base64, "base64")
+            });
+          if (event.type === "controller_changed")
+            input.onEvent({
+              type: "controller_changed",
+              attachmentID: event.attachment_id ?? undefined,
+              generation: event.generation
+            });
+          if (event.type === "title_changed")
+            input.onEvent({ type: "title_changed", title: event.title });
+          if (event.type === "foreground_process_changed")
+            input.onEvent({ type: "foreground_process_changed", process: event.process });
+          if (event.type === "exited") {
+            input.onEvent({
+              type: "exited",
+              exitCode: event.exit_code ?? undefined,
+              finalOffset: event.final_offset
+            });
+            return;
+          }
+        }
+      } finally {
+        if (!detached)
+          input.onEnd();
+      }
+    };
+    let activated = false;
+    return {
+      terminal: response.terminal,
+      role: response.role,
+      generation: response.generation,
+      replay: {
+        requestedOffset: response.requested_offset,
+        availableOffset: response.available_offset,
+        endOffset: response.end_offset,
+        truncated: response.truncated,
+        data: Buffer.from(response.replay_base64, "base64")
+      },
+      activate() {
+        if (activated || detached)
+          return;
+        activated = true;
+        pump().catch(() => {});
+      },
+      detach() {
+        if (detached)
+          return;
+        detached = true;
+        socket.destroy();
+      }
+    };
+  } catch (error) {
+    socket.destroy();
+    throw error;
+  }
+}
+function encode(value) {
+  const payload = Buffer.from(JSON.stringify(value));
+  if (payload.length > MaxFrameBytes)
+    throw new Error("opencode-pty frame too large");
+  const output = Buffer.allocUnsafe(payload.length + 4);
+  output.writeUInt32BE(payload.length);
+  payload.copy(output, 4);
+  return output;
+}
+async function* decoder(socket) {
+  let pending = Buffer.alloc(0);
+  for await (const value of socket) {
+    const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+    pending = pending.length === 0 ? chunk : Buffer.concat([pending, chunk]);
+    while (pending.length >= 4) {
+      const length = pending.readUInt32BE(0);
+      if (length > MaxFrameBytes)
+        throw new Error("opencode-pty frame too large");
+      if (pending.length < length + 4)
+        break;
+      yield pending.subarray(4, length + 4);
+      pending = pending.subarray(length + 4);
+    }
+  }
+  if (pending.length !== 0)
+    throw new Error("opencode-pty truncated frame");
+}
+function decode(payload) {
+  return Schema.decodeUnknownSync(WireResponse2)(JSON.parse(Buffer.from(payload).toString("utf8")));
+}
+function failure(kind, cause) {
+  return new DaemonError2({ kind, message: cause instanceof Error ? cause.message : String(cause) });
+}
+
+export { WireTerminal2, WireResponse2, DaemonError2, makeDaemonTransport2 };

package/dist/chunks/worktree-skcgd3vv.js

@@ -0,0 +1,190 @@
+import {
+  RelativePath2
+} from "./worktree-922hggd3.js";
+import {
+  Service74,
+  node79
+} from "./worktree-z82wee6n.js";
+import {
+  Service45,
+  node48
+} from "./worktree-f8jtvgnz.js";
+import {
+  isHome2,
+  names3
+} from "./worktree-tcezcvh9.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/filesystem/search.ts
+var exports_search = {};
+__export(exports_search, {
+  FileSystemSearch: () => exports_search,
+  Options: () => Options2,
+  Service: () => Service14,
+  configured: () => configured2,
+  fffLayer: () => fffLayer2,
+  layer: () => layer8,
+  node: () => node17,
+  ripgrepLayer: () => ripgrepLayer2
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import path from "path";
+import { Clock, Context, Deferred, Duration, Effect, Layer, Schema, Scope } from "effect";
+import { Fff } from "#fff";
+import fuzzysort from "fuzzysort";
+import { FileSystem } from "@opencode/schema/filesystem";
+var Options2 = Schema.Struct({
+  fff: Schema.optional(Schema.Boolean)
+});
+
+class Service14 extends Context.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(path.sep) ? "directory" : "file";
+    return FileSystem.Entry.make({
+      path: RelativePath2.make(relative),
+      type
+    });
+  });
+}
+var ripgrepLayer2 = Layer.effect(Service14, Effect.gen(function* () {
+  const location = yield* Service74;
+  const ripgrep = yield* Service45;
+  const scope = yield* Scope.Scope;
+  const clock = yield* Clock.Clock;
+  const home = isHome2(location.directory);
+  let index = emptyIndex();
+  let initialized = false;
+  let settledAt = Number.NEGATIVE_INFINITY;
+  let refreshing;
+  const scan = Effect.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 ? [...names3()].map((name) => `${name}/**`) : undefined,
+      onEntry: (entry) => Effect.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("/") + path.sep;
+          if (!next.directories.has(directory))
+            next.directories.set(directory, previous.directories.get(directory) ?? fuzzysort.prepare(directory));
+        });
+      })
+    });
+    index = next;
+    initialized = true;
+  }).pipe(Effect.orDie);
+  const refresh = Effect.suspend(() => {
+    if (refreshing)
+      return initialized ? Effect.void : Deferred.await(refreshing);
+    if (initialized && clock.currentTimeMillisUnsafe() < settledAt + REFRESH_INTERVAL)
+      return Effect.void;
+    const attempt = Deferred.makeUnsafe();
+    refreshing = attempt;
+    return scan.pipe(Effect.onExit((exit) => Effect.sync(() => {
+      settledAt = clock.currentTimeMillisUnsafe();
+      if (refreshing === attempt)
+        refreshing = undefined;
+      Deferred.doneUnsafe(attempt, exit);
+    })), Effect.forkIn(scope), Effect.flatMap(() => initialized ? Effect.void : Deferred.await(attempt)));
+  });
+  return Service14.of({
+    find: (input) => Effect.gen(function* () {
+      yield* refresh;
+      return search(index, input);
+    })
+  });
+}));
+var fffLayer2 = Layer.effect(Service14, Effect.gen(function* () {
+  const location = yield* Service74;
+  const result = yield* Effect.try({
+    try: () => Fff.create({
+      basePath: location.directory,
+      aiMode: true,
+      disableMmapCache: true,
+      disableContentIndexing: true
+    }),
+    catch: (cause) => cause
+  }).pipe(Effect.catch((error) => Effect.logWarning("failed to initialize fff", { error }).pipe(Effect.as(undefined))));
+  if (!result?.ok) {
+    if (result)
+      yield* Effect.logWarning("failed to initialize fff", { error: result.error });
+    return Service14.of({
+      find: () => Effect.succeed([])
+    });
+  }
+  yield* Effect.addFinalizer(() => Effect.sync(() => result.value.destroy()));
+  return Service14.of({
+    find: (input) => Effect.sync(() => {
+      const options = { pageIndex: 0, pageSize: input.limit ?? 50 };
+      const items = (() => {
+        if (input.type === "file") {
+          const found = result.value.fileSearch(input.query.trim(), options);
+          if (!found.ok)
+            throw found.error;
+          return found.value.items.map((item, index) => ({
+            path: item.relativePath,
+            type: "file",
+            score: found.value.scores[index]?.total ?? 0
+          }));
+        }
+        if (input.type === "directory") {
+          const found = result.value.directorySearch(input.query.trim(), options);
+          if (!found.ok)
+            throw found.error;
+          return found.value.items.map((item, index) => ({
+            path: item.relativePath,
+            type: "directory",
+            score: found.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 FileSystem.Entry.make({
+          path: RelativePath2.make(relative + (item.type === "directory" ? path.sep : "")),
+          type: item.type
+        });
+      });
+    })
+  });
+}));
+var layer8 = (options) => Layer.unwrap(Effect.gen(function* () {
+  const location = yield* Service74;
+  if (location.workspaceID)
+    return ripgrepLayer2;
+  if (options?.fff === false || options?.fff === undefined && process.platform === "win32" || !Fff.available())
+    return ripgrepLayer2;
+  return location.vcs && !isHome2(location.directory) ? fffLayer2 : ripgrepLayer2;
+}));
+function configured2(options) {
+  return makeLocationNode({ service: Service14, layer: layer8(options), deps: [node79, node48] });
+}
+var node17 = configured2();
+
+export { Options2, Service14, ripgrepLayer2, fffLayer2, layer8, configured2, node17, exports_search };