@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-jgw081v5.js

@@ -0,0 +1,252 @@
+import {
+  exports_git as exports_git2
+} from "./location-mutation-0brv01ad.js";
+import {
+  DirectoryUnavailableError,
+  canonical
+} from "./location-mutation-8vhzxx5g.js";
+import {
+  Slug
+} from "./location-mutation-df3v2q6j.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  WorktreeTable
+} from "./location-mutation-mh28new4.js";
+import {
+  exports_schema
+} from "./location-mutation-8v47shgf.js";
+import {
+  ProjectTable
+} from "./location-mutation-88jbfw8z.js";
+import {
+  exports_git
+} from "./location-mutation-kcwh27nh.js";
+import {
+  AbsolutePath
+} from "./location-mutation-j07kk359.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  exports_database
+} from "./location-mutation-j0ksmf2f.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/worktree.ts
+var exports_worktree = {};
+__export(exports_worktree, {
+  refreshNode: () => refreshNode,
+  refreshAfterBoot: () => refreshAfterBoot,
+  node: () => node,
+  Worktree: () => exports_worktree,
+  StrategyUnavailableError: () => StrategyUnavailableError,
+  StrategyID: () => StrategyID,
+  SourceDirectoryNotFoundError: () => SourceDirectoryNotFoundError,
+  Service: () => Service,
+  RemoveInput: () => RemoveInput,
+  RefreshResult: () => RefreshResult,
+  RefreshInput: () => RefreshInput,
+  ListInput: () => ListInput,
+  ListEntry: () => ListEntry,
+  List: () => List,
+  InvalidDirectoryError: () => InvalidDirectoryError,
+  Info: () => Info,
+  Event: () => Event,
+  DuplicateStrategyError: () => DuplicateStrategyError,
+  DirectoryUnavailableError: () => DirectoryUnavailableError,
+  DestinationExistsError: () => DestinationExistsError,
+  CreateInput: () => CreateInput
+});
+import { Context, Effect, Layer, Schema } from "effect";
+import { and, asc, desc, eq, isNotNull, isNull, ne, or } from "drizzle-orm";
+import path from "path";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { makeGlobalNode, makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Worktree } from "@opencode-ai/schema/worktree";
+var StrategyID = Worktree.StrategyID;
+var CreateInput = Worktree.CreateInput;
+var RemoveInput = Worktree.RemoveInput;
+var RefreshInput = Schema.Struct({
+  projectID: exports_schema.ID
+}).annotate({ identifier: "Worktree.RefreshInput" });
+var RefreshResult = Schema.Struct({
+  updated: Schema.Array(AbsolutePath),
+  removed: Schema.Array(AbsolutePath)
+}).annotate({ identifier: "Worktree.RefreshResult" });
+var Info = Worktree.Info;
+var ListInput = Worktree.ListInput;
+var List = Worktree.List;
+var ListEntry = Schema.Struct({
+  directory: AbsolutePath,
+  type: Schema.Literals(["root", "worktree"])
+}).annotate({ identifier: "Worktree.ListEntry" });
+
+class SourceDirectoryNotFoundError extends Schema.TaggedErrorClass()("Worktree.SourceDirectoryNotFoundError", { projectID: exports_schema.ID, directory: Schema.optional(AbsolutePath) }) {
+}
+
+class DestinationExistsError extends Schema.TaggedErrorClass()("Worktree.DestinationExistsError", { directory: AbsolutePath }) {
+}
+
+class InvalidDirectoryError extends Schema.TaggedErrorClass()("Worktree.InvalidDirectoryError", { directory: AbsolutePath }) {
+}
+
+class StrategyUnavailableError extends Schema.TaggedErrorClass()("Worktree.StrategyUnavailableError", { strategy: StrategyID }) {
+}
+
+class DuplicateStrategyError extends Schema.TaggedErrorClass()("Worktree.DuplicateStrategyError", { strategy: StrategyID }) {
+}
+var Event = Worktree.Event;
+
+class Service extends Context.Service()("@opencode/v2/Worktree") {
+}
+var refreshAfterBoot = Effect.gen(function* () {
+  const location = yield* exports_location.Service;
+  const worktrees = yield* Service;
+  yield* Effect.gen(function* () {
+    yield* Effect.logInfo("worktree refresh started", { projectID: location.project.id });
+    const result = yield* worktrees.refresh({ projectID: location.project.id });
+    yield* Effect.logInfo("worktree refresh done", {
+      projectID: location.project.id,
+      updated: result.updated,
+      removed: result.removed
+    });
+  }).pipe(Effect.catchCause((cause) => Effect.logWarning("worktree refresh failed", { cause })), Effect.forkScoped, Effect.asVoid);
+});
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const db = (yield* exports_database.Service).db;
+  const bus = yield* exports_bus.Service;
+  const changed = Effect.fnUntraced(function* (projectID, update) {
+    if (update)
+      yield* bus.publish(Event.Updated, { projectID });
+  });
+  const ops = {
+    list: Effect.fn("Worktree.list")(function* (projectID) {
+      const rows = yield* db.select({ directory: WorktreeTable.directory, strategy: WorktreeTable.strategy }).from(WorktreeTable).where(eq(WorktreeTable.project_id, projectID)).orderBy(desc(WorktreeTable.time_created), asc(WorktreeTable.directory)).all().pipe(Effect.orDie);
+      return rows.map((row) => ({ directory: row.directory, strategy: row.strategy ?? undefined }));
+    }),
+    find: Effect.fnUntraced(function* (projectID, directory) {
+      const row = yield* db.select({ directory: WorktreeTable.directory, strategy: WorktreeTable.strategy }).from(WorktreeTable).where(and(eq(WorktreeTable.project_id, projectID), eq(WorktreeTable.directory, directory))).get().pipe(Effect.orDie);
+      return row ? { directory: row.directory, strategy: row.strategy ?? undefined } : undefined;
+    }),
+    primary: Effect.fnUntraced(function* (projectID) {
+      return yield* db.select({ directory: ProjectTable.worktree }).from(ProjectTable).where(eq(ProjectTable.id, projectID)).get().pipe(Effect.orDie);
+    }),
+    create: Effect.fnUntraced(function* (input, tx) {
+      return (yield* (tx ?? db).insert(WorktreeTable).values({ project_id: input.projectID, directory: input.directory, strategy: input.strategy }).onConflictDoUpdate({
+        target: [WorktreeTable.project_id, WorktreeTable.directory],
+        set: { strategy: input.strategy ?? null },
+        setWhere: input.strategy ? or(isNull(WorktreeTable.strategy), ne(WorktreeTable.strategy, input.strategy)) : isNotNull(WorktreeTable.strategy)
+      }).returning({ directory: WorktreeTable.directory }).get().pipe(Effect.orDie)) !== undefined;
+    }),
+    remove: Effect.fnUntraced(function* (projectID, directory, tx) {
+      return (yield* (tx ?? db).delete(WorktreeTable).where(and(eq(WorktreeTable.project_id, projectID), eq(WorktreeTable.directory, directory))).returning({ directory: WorktreeTable.directory }).get().pipe(Effect.orDie)) !== undefined;
+    })
+  };
+  const registry = new Map;
+  const register = Effect.fn("Worktree.register")(function* (strategy) {
+    if (registry.has(strategy.id))
+      return yield* new DuplicateStrategyError({ strategy: strategy.id });
+    registry.set(strategy.id, strategy);
+  });
+  const gitStrategy = yield* exports_git2.make;
+  yield* register(gitStrategy).pipe(Effect.orDie);
+  const strategies = () => Array.from(registry.values());
+  const source = Effect.fnUntraced(function* (input, projectID) {
+    const sourceDirectory = input ?? (yield* ops.primary(projectID))?.directory;
+    if (!sourceDirectory)
+      return yield* new SourceDirectoryNotFoundError({ projectID });
+    const resolved = yield* canonical(fs, sourceDirectory);
+    if ((yield* ops.find(projectID, resolved)) === undefined)
+      return yield* new SourceDirectoryNotFoundError({ projectID, directory: resolved });
+    return resolved;
+  });
+  const getStrategy = Effect.fnUntraced(function* (id) {
+    const found = registry.get(id);
+    if (!found)
+      return yield* new StrategyUnavailableError({ strategy: id });
+    return found;
+  });
+  const create = Effect.fn("Worktree.create")(function* (input) {
+    const selected = yield* getStrategy(input.strategy);
+    const sourceDirectory = yield* source(input.from, input.projectID);
+    yield* fs.makeDirectory(input.directory, { recursive: true }).pipe(Effect.orDie);
+    const name = input.name ?? Slug.create();
+    let suffix = 1;
+    let worktreeDirectory = AbsolutePath.make(path.join(input.directory, name));
+    while (yield* fs.existsSafe(worktreeDirectory)) {
+      suffix++;
+      if (suffix > 10)
+        return yield* new DestinationExistsError({ directory: worktreeDirectory });
+      worktreeDirectory = AbsolutePath.make(path.join(input.directory, `${name}-${suffix}`));
+    }
+    const result = yield* selected.create({
+      directory: worktreeDirectory,
+      sourceDirectory
+    });
+    yield* changed(input.projectID, yield* ops.create({
+      projectID: input.projectID,
+      directory: result.directory,
+      strategy: input.strategy
+    }));
+    return result;
+  });
+  const remove = Effect.fn("Worktree.remove")(function* (input) {
+    const worktreeDirectory = yield* canonical(fs, input.directory);
+    const stored = yield* ops.find(input.projectID, worktreeDirectory);
+    if (!stored?.strategy)
+      return yield* new InvalidDirectoryError({ directory: worktreeDirectory });
+    yield* (yield* getStrategy(StrategyID.make(stored.strategy))).remove({
+      directory: worktreeDirectory,
+      force: input.force
+    });
+    yield* changed(input.projectID, yield* ops.remove(input.projectID, worktreeDirectory));
+  });
+  const refresh = Effect.fn("Worktree.refresh")(function* (input) {
+    const stored = yield* ops.list(input.projectID);
+    const checked = yield* Effect.forEach(stored, (item) => fs.isDir(item.directory).pipe(Effect.map((exists) => ({ ...item, exists }))), { concurrency: "unbounded" });
+    const sourceDirectories = checked.filter((item) => item.strategy === undefined && item.exists).map((item) => item.directory);
+    const discovered = yield* Effect.forEach(sourceDirectories, (sourceDirectory) => Effect.forEach(strategies(), (strategy) => strategy.list(sourceDirectory).pipe(Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.succeed([])), Effect.map((items) => items.map((item) => ({
+      directory: item.directory,
+      strategy: item.type === "worktree" ? strategy.id : undefined
+    }))))), { concurrency: "unbounded" }).pipe(Effect.map((sets) => new Map(sets.flat(2).map((item) => [item.directory, item])).values().toArray()));
+    const removed = checked.filter((item) => !item.exists).map((item) => item.directory);
+    const result = yield* db.transaction((tx) => Effect.all({
+      updated: Effect.forEach(discovered, (item) => ops.create({
+        projectID: input.projectID,
+        directory: item.directory,
+        strategy: item.strategy
+      }, tx)),
+      removed: Effect.forEach(removed, (directory) => ops.remove(input.projectID, directory, tx))
+    })).pipe(Effect.orDie);
+    const changes = {
+      updated: discovered.filter((_, index) => result.updated[index]).map((item) => item.directory),
+      removed: removed.filter((_, index) => result.removed[index])
+    };
+    yield* changed(input.projectID, changes.updated.length > 0 || changes.removed.length > 0);
+    return changes;
+  });
+  return Service.of({
+    register,
+    list: ops.list,
+    create,
+    remove,
+    refresh
+  });
+}));
+var node = makeGlobalNode({
+  service: Service,
+  layer,
+  deps: [FSUtil.node, exports_git.node, exports_bus.node, exports_database.node]
+});
+var refreshNode = makeLocationNode({
+  name: "worktree-refresh",
+  layer: Layer.effectDiscard(refreshAfterBoot),
+  deps: [node, exports_location.node]
+});
+
+export { StrategyID, CreateInput, RemoveInput, RefreshInput, RefreshResult, Info, ListInput, List, ListEntry, SourceDirectoryNotFoundError, DestinationExistsError, InvalidDirectoryError, StrategyUnavailableError, DuplicateStrategyError, Event, Service, refreshAfterBoot, node, refreshNode, exports_worktree };

package/dist/chunks/location-mutation-jm193w7g.js

@@ -0,0 +1,112 @@
+import {
+  exports_session
+} from "./location-mutation-wc69wynm.js";
+import {
+  exports_job
+} from "./location-mutation-gpee7ppy.js";
+import {
+  exports_agent
+} from "./location-mutation-0ms0v4tv.js";
+import {
+  exports_location_service_map
+} from "./location-mutation-zdkg1k91.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin/runtime.ts
+var exports_runtime = {};
+__export(exports_runtime, {
+  providerNodeWithCell: () => providerNodeWithCell,
+  providerNode: () => providerNode,
+  providerLayerWithCell: () => providerLayerWithCell,
+  node: () => node,
+  makeCell: () => makeCell,
+  layerWithCell: () => layerWithCell,
+  layer: () => layer,
+  Service: () => Service,
+  PluginRuntime: () => exports_runtime
+});
+import { Context, Effect, Layer } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+class Service extends Context.Service()("@opencode/PluginRuntime") {
+}
+var makeCell = () => ({});
+var unavailable = () => Effect.die(new Error("Plugin runtime is unavailable"));
+var require2 = (cell, f) => Effect.suspend(() => {
+  const runtime = cell.runtime;
+  if (runtime === undefined)
+    return unavailable();
+  return f(runtime);
+});
+var defaultCell = makeCell();
+var layerWithCell = (cell) => Layer.succeed(Service, Service.of({
+  session: {
+    get: (sessionID) => require2(cell, (runtime) => runtime.session.get(sessionID)),
+    create: (input) => require2(cell, (runtime) => runtime.session.create(input)),
+    messages: (input) => require2(cell, (runtime) => runtime.session.messages(input)),
+    prompt: (input) => require2(cell, (runtime) => runtime.session.prompt(input)),
+    generate: (input) => require2(cell, (runtime) => runtime.session.generate(input)),
+    command: (input) => require2(cell, (runtime) => runtime.session.command(input)),
+    rename: (input) => require2(cell, (runtime) => runtime.session.rename(input)),
+    resume: (sessionID) => require2(cell, (runtime) => runtime.session.resume(sessionID)),
+    interrupt: (sessionID) => require2(cell, (runtime) => runtime.session.interrupt(sessionID)),
+    synthetic: (input) => require2(cell, (runtime) => runtime.session.synthetic(input)),
+    wait: (sessionID) => require2(cell, (runtime) => runtime.session.wait(sessionID))
+  },
+  job: {
+    start: (input) => require2(cell, (runtime) => runtime.job.start(input)),
+    wait: (input) => require2(cell, (runtime) => runtime.job.wait(input)),
+    block: (input) => require2(cell, (runtime) => runtime.job.block(input)),
+    background: (id) => require2(cell, (runtime) => runtime.job.background(id)),
+    cancel: (id) => require2(cell, (runtime) => runtime.job.cancel(id))
+  },
+  location: {
+    agent: {
+      list: (ref) => require2(cell, (runtime) => runtime.location.agent.list(ref))
+    }
+  }
+}));
+var providerLayerWithCell = (cell) => Layer.effectDiscard(Effect.gen(function* () {
+  const sessions = yield* exports_session.Service;
+  const jobs = yield* exports_job.Service;
+  const locations = yield* exports_location_service_map.Service;
+  const runtime = {
+    session: sessions,
+    job: jobs,
+    location: {
+      agent: {
+        list: (ref) => Effect.gen(function* () {
+          const location = yield* exports_location.Service;
+          const agents = yield* exports_agent.Service;
+          return {
+            location: new exports_location.Info({
+              directory: location.directory,
+              workspaceID: location.workspaceID,
+              project: location.project
+            }),
+            data: yield* agents.list()
+          };
+        }).pipe(Effect.provide(locations.get(ref)), Effect.orDie)
+      }
+    }
+  };
+  cell.runtime = runtime;
+  yield* Effect.addFinalizer(() => Effect.sync(() => {
+    if (cell.runtime === runtime)
+      cell.runtime = undefined;
+  }));
+}));
+var layer = layerWithCell(defaultCell);
+var node = makeGlobalNode({ service: Service, layer, deps: [] });
+var providerNodeWithCell = (cell) => makeGlobalNode({
+  name: "plugin-runtime-provider",
+  layer: providerLayerWithCell(cell),
+  deps: [node, exports_session.node, exports_job.node, exports_location_service_map.node]
+});
+var providerNode = providerNodeWithCell(defaultCell);
+
+export { Service, makeCell, layerWithCell, providerLayerWithCell, layer, node, providerNodeWithCell, providerNode, exports_runtime };

package/dist/chunks/location-mutation-js0qxxzx.js

@@ -0,0 +1,103 @@
+import {
+  exports_permission
+} from "./location-mutation-gjaba53s.js";
+import {
+  exports_state
+} from "./location-mutation-wt193r4g.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/skill.ts
+var exports_skill = {};
+__export(exports_skill, {
+  toModelOutput: () => toModelOutput,
+  node: () => node,
+  available: () => available,
+  UrlSource: () => UrlSource,
+  Source: () => Source,
+  Skill: () => exports_skill,
+  Service: () => Service,
+  Name: () => Name,
+  Info: () => Info,
+  ID: () => ID,
+  Event: () => Event,
+  EmbeddedSource: () => EmbeddedSource,
+  DirectorySource: () => DirectorySource
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import path from "path";
+import { Context, Effect, Layer } from "effect";
+import { Skill } from "@opencode-ai/schema/skill";
+import { Event } from "@opencode-ai/schema/skill";
+var DirectorySource = Skill.DirectorySource;
+var UrlSource = Skill.UrlSource;
+var EmbeddedSource = Skill.EmbeddedSource;
+var Source = Skill.Source;
+var Info = Skill.Info;
+var ID = Skill.ID;
+var Name = Skill.Name;
+var available = (skills, agent) => skills.filter((skill) => exports_permission.evaluate("skill", skill.id, agent.permissions).effect !== "deny");
+var toModelOutput = (skill, files) => {
+  const directory = path.dirname(skill.location);
+  return [
+    `<skill_content name="${skill.name}">`,
+    `# Skill: ${skill.name}`,
+    "",
+    skill.content.trim(),
+    "",
+    `Base directory for this skill: ${directory}`,
+    "Relative paths in this skill (e.g., scripts/, reference/) are relative to this base directory.",
+    "Note: file list is sampled.",
+    "",
+    "<skill_files>",
+    ...files.map((file) => `<file>${file}</file>`),
+    "</skill_files>",
+    "</skill_content>"
+  ].join(`
+`);
+};
+
+class Service extends Context.Service()("@opencode/Skill") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const state = exports_state.create({
+    name: "skill",
+    initial: () => ({ skills: new Map }),
+    draft: (draft) => ({
+      list: () => Array.from(draft.skills.values()),
+      add: (skill) => {
+        draft.skills.set(skill.id, { ...skill });
+      },
+      update: (id, update) => {
+        const current = draft.skills.get(ID.make(id));
+        if (!current)
+          return;
+        update(current);
+        current.id = ID.make(id);
+      },
+      remove: (id) => {
+        draft.skills.delete(ID.make(id));
+      }
+    }),
+    finalize: () => bus.publish(Skill.Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  return Service.of({
+    transform: state.transform,
+    reload: state.reload,
+    list: Effect.fn("Skill.list")(function* () {
+      return Array.from(state.get().skills.values());
+    })
+  });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_bus.node]
+});
+
+export { DirectorySource, UrlSource, EmbeddedSource, Source, Info, ID, Name, available, toModelOutput, Service, node, exports_skill, Event };

package/dist/chunks/location-mutation-jssy2dr3.js

@@ -0,0 +1,18 @@
+import {
+  createProviderPlugin
+} from "./location-mutation-0zz82cjq.js";
+import {
+  __require
+} from "./location-mutation-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/location-mutation-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/location-mutation-k6vwd7kr.js

@@ -0,0 +1,174 @@
+import {
+  lazy
+} from "./location-mutation-8w9tzfz1.js";
+import {
+  load
+} from "./location-mutation-dkmkay92.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/filesystem/watcher.ts
+var exports_watcher = {};
+__export(exports_watcher, {
+  testLayer: () => testLayer,
+  node: () => node,
+  nativeNode: () => nativeNode,
+  nativeLayer: () => nativeLayer,
+  layer: () => layer,
+  hasNativeBinding: () => hasNativeBinding,
+  configured: () => configured,
+  Watcher: () => exports_watcher,
+  Test: () => Test,
+  Service: () => Service,
+  Options: () => Options,
+  Native: () => Native,
+  Event: () => Event
+});
+import { createWrapper } from "@parcel/watcher/wrapper";
+import { FileSystem } from "@opencode-ai/schema/filesystem";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { Cause, Context, Effect, Layer, PubSub, RcMap, Schema, Stream } from "effect";
+import { watch as watchFileSystem } from "node:fs";
+import path from "path";
+var SUBSCRIBE_TIMEOUT_MS = 1e4;
+var Event = { Updated: FileSystem.Event.Changed };
+var watcher = lazy(() => {
+  try {
+    return createWrapper(load());
+  } catch {
+    return;
+  }
+});
+function getBackend() {
+  if (process.platform === "win32")
+    return "windows";
+  if (process.platform === "darwin")
+    return "fs-events";
+  if (process.platform === "linux")
+    return "inotify";
+}
+var hasNativeBinding = () => !!watcher();
+
+class Native extends Context.Service()("@opencode/Watcher/Native") {
+}
+var Options = Schema.Struct({
+  enabled: Schema.optional(Schema.Boolean)
+});
+
+class Service extends Context.Service()("@opencode/Watcher") {
+}
+
+class Test extends Context.Service()("@opencode/Watcher/Test") {
+}
+var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
+  if (options?.enabled === false) {
+    return Service.of({ subscribe: () => Effect.succeed(Stream.empty) });
+  }
+  const native = yield* Native;
+  const watchers = yield* RcMap.make({
+    lookup: (key) => Effect.gen(function* () {
+      const pubsub = yield* Effect.acquireRelease(PubSub.unbounded(), (pubsub2) => PubSub.shutdown(pubsub2));
+      const subscription = yield* Effect.acquireRelease(native.subscribe({
+        type: key.type,
+        target: key.target,
+        ignore: key.ignore,
+        publish: (update) => PubSub.publishUnsafe(pubsub, update)
+      }), (subscription2) => subscription2 ? Effect.promise(() => subscription2.unsubscribe()).pipe(Effect.ignoreCause, Effect.andThen(Effect.logInfo("watcher stopped", { path: key.target, type: key.type }))) : Effect.void, { interruptible: true });
+      if (!subscription) {
+        yield* PubSub.shutdown(pubsub);
+        return pubsub;
+      }
+      yield* Effect.logInfo("watcher started", {
+        path: key.target,
+        type: key.type,
+        backend: subscription.backend,
+        ignores: key.ignore.length
+      });
+      return pubsub;
+    })
+  });
+  const subscribe = (input) => {
+    const target = path.resolve(input.path);
+    const ignore = [...new Set(input.type === "directory" ? input.ignore ?? [] : [])].toSorted();
+    return Effect.gen(function* () {
+      yield* Effect.logInfo("watcher subscribe", {
+        path: target,
+        type: input.type,
+        ignores: ignore.length
+      });
+      return Stream.unwrap(Effect.gen(function* () {
+        const pubsub = yield* RcMap.get(watchers, { type: input.type, target, ignore });
+        return Stream.fromPubSub(pubsub);
+      }));
+    });
+  };
+  return Service.of({ subscribe });
+}));
+var testLayer = Layer.effectContext(Effect.gen(function* () {
+  const subscriptions = [];
+  const active = new Set;
+  const native = Native.of({
+    subscribe: (input) => Effect.sync(() => {
+      subscriptions.push(input.type === "file" ? { path: input.target, type: "file" } : input.ignore.length > 0 ? { path: input.target, type: "directory", ignore: input.ignore } : { path: input.target, type: "directory" });
+      active.add(input.publish);
+      return {
+        unsubscribe: () => {
+          active.delete(input.publish);
+          return Promise.resolve();
+        }
+      };
+    })
+  });
+  const context = yield* Layer.build(layer().pipe(Layer.provide(Layer.succeed(Native, native))));
+  const test = Test.of({
+    subscribe: Context.get(context, Service).subscribe,
+    emit: (update) => Effect.sync(() => active.forEach((publish) => publish(update))),
+    subscriptions: () => Effect.sync(() => [...subscriptions])
+  });
+  return Context.empty().pipe(Context.add(Service, test), Context.add(Test, test));
+}));
+var nativeLayer = Layer.succeed(Native, Native.of({
+  subscribe: (input) => {
+    if (input.type === "file") {
+      return Effect.sync(() => {
+        const directory = path.dirname(input.target);
+        const subscription = watchFileSystem(directory, { recursive: false }, (_event, file) => {
+          if (file && path.resolve(directory, file.toString()) !== input.target)
+            return;
+          input.publish({ path: input.target, type: "update" });
+        });
+        if ("on" in subscription && typeof subscription.on === "function") {
+          subscription.on("error", (error) => Effect.runFork(Effect.logError("watcher callback failed", { path: input.target, error })));
+        }
+        return { unsubscribe: () => Promise.resolve(subscription.close()), backend: "node" };
+      });
+    }
+    return subscribeDirectory(watcher(), getBackend(), input.target, input.ignore, input.publish);
+  }
+}));
+var nativeNode = makeGlobalNode({ service: Native, layer: nativeLayer, deps: [] });
+function configured(options) {
+  return makeGlobalNode({ service: Service, layer: layer(options), deps: [nativeNode] });
+}
+var node = configured();
+function subscribeDirectory(native, backend, directory, ignore, publish) {
+  if (!native || !backend) {
+    return Effect.logError("watcher backend not supported", { directory, platform: process.platform }).pipe(Effect.as(undefined));
+  }
+  const callback = (error, updates) => {
+    if (error)
+      Effect.runFork(Effect.logError("watcher callback failed", { error }));
+    for (const update of updates)
+      publish(update);
+  };
+  const pending = native.subscribe(directory, callback, { ignore: [...ignore], backend });
+  return Effect.promise(() => pending).pipe(Effect.map((subscription) => ({ unsubscribe: () => subscription.unsubscribe(), backend })), Effect.onInterrupt(() => Effect.sync(() => {
+    pending.then((subscription) => subscription.unsubscribe()).catch(() => {});
+  })), Effect.timeout(SUBSCRIBE_TIMEOUT_MS), Effect.catchCause((cause) => Effect.logError("failed to subscribe", {
+    directory,
+    cause: Cause.pretty(cause)
+  }).pipe(Effect.as(undefined))));
+}
+
+export { Event, hasNativeBinding, Native, Options, Service, Test, layer, testLayer, nativeLayer, nativeNode, configured, node, exports_watcher };