@opencode-ai/core 0.0.0-dev-19121 → 0.0.0-dev-19127

package/dist/chunks/{location-mutation-jdpn2m95.js → worktree-6wghtbd2.js}

@@ -2,46 +2,46 @@ import {
   NotFound2,
   WrongKind2,
   Failed2
-} from "./location-mutation-2a5m3afh.js";
+} from "./worktree-2a5m3afh.js";
 import {
   Service76
-} from "./location-mutation-ext0y26q.js";
+} from "./worktree-6hwsp9rp.js";
 import {
-  Service53
-} from "./location-mutation-wkpm2t5g.js";
+  Service51
+} from "./worktree-1kgee81n.js";
 import {
-  Service15
-} from "./location-mutation-9v1bmnwj.js";
+  Service13
+} from "./worktree-4yv6mxgz.js";
 import {
-  Service13,
+  Service15,
   readText2,
   syncTextBom2
-} from "./location-mutation-jph4yfm0.js";
+} from "./worktree-2sj4fdt9.js";
 import {
   externalDirectoryPermission2,
   resolvePath2,
-  Service62
-} from "./location-mutation-78k4jgfg.js";
+  Service18
+} from "./worktree-5cvw65fn.js";
 import {
-  Service63
-} from "./location-mutation-msb8yzxf.js";
+  Service70
+} from "./worktree-sgacr2dd.js";
 import {
   fileDiff2
-} from "./location-mutation-6prwharc.js";
+} from "./worktree-6prwharc.js";
 import {
   __export
-} from "./location-mutation-9rqn6x4v.js";
+} from "./worktree-9rqn6x4v.js";
 
 // src/tool/plugin/patch.ts
 var exports_patch = {};
 __export(exports_patch, {
   Applied: () => Applied2,
-  Input: () => Input7,
-  Output: () => Output5,
+  Input: () => Input9,
+  Output: () => Output6,
   PatchTool: () => exports_patch,
-  Plugin: () => Plugin37,
-  name: () => name7,
-  toModelContent: () => toModelContent4
+  Plugin: () => Plugin11,
+  name: () => name9,
+  toModelContent: () => toModelContent5
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { FileDiff } from "@opencode-ai/schema/file-diff";
@@ -86,8 +86,8 @@ It is important to remember:
 `;
 
 // src/tool/plugin/patch.ts
-var name7 = "patch";
-var Input7 = Schema.Struct({
+var name9 = "patch";
+var Input9 = Schema.Struct({
   patchText: Schema.String.annotate({
     description: "The full patch text describing add, update, and delete operations"
   })
@@ -97,30 +97,30 @@ var Applied2 = Schema.Struct({
   resource: Schema.String,
   target: Schema.String
 });
-var Output5 = Schema.Struct({
+var Output6 = Schema.Struct({
   applied: Schema.Array(Applied2),
   files: Schema.Array(FileDiff.Info)
 });
-var toModelContent4 = (output) => [
+var toModelContent5 = (output) => [
   "Success. Updated the following files:",
   ...output.applied.map((item) => `${item.type === "add" ? "A" : item.type === "delete" ? "D" : "M"} ${item.resource}`)
 ].join(`
 `);
-var Plugin37 = {
+var Plugin11 = {
   id: "opencode.tool.patch",
   effect: Effect.fn("PatchTool.Plugin")(function* (ctx) {
-    const environment = yield* Service53;
-    const mutation = yield* Service62;
-    const fileMutation = yield* Service13;
-    const formatter = yield* Service15;
+    const environment = yield* Service51;
+    const mutation = yield* Service18;
+    const fileMutation = yield* Service15;
+    const formatter = yield* Service13;
     const location = yield* Service76;
-    const permission = yield* Service63;
+    const permission = yield* Service70;
     yield* ctx.tool.transform((editor) => editor.add({
-      name: name7,
+      name: name9,
       options: { codemode: false, permission: "edit" },
       description: patch_default,
-      input: Input7,
-      output: Output5,
+      input: Input9,
+      output: Output6,
       execute: (input, context) => {
         const applied = [];
         const parsed = Patch.parse(input.patchText);
@@ -273,7 +273,7 @@ var Plugin37 = {
           return { applied, files };
         }).pipe(fileMutation.withLock(lockTargets), Effect.map((output) => ({
           output,
-          content: toModelContent4(output),
+          content: toModelContent5(output),
           metadata: { files: output.files }
         })), Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: "Unable to apply patch", error })));
       }
@@ -330,4 +330,4 @@ function trimDiff(diff) {
 `);
 }
 
-export { name7, Input7, Applied2, Output5, toModelContent4, Plugin37, exports_patch };
+export { name9, Input9, Applied2, Output6, toModelContent5, Plugin11, exports_patch };

package/dist/chunks/{location-mutation-bjg9h0sq.js → worktree-6wj53xsq.js}

@@ -1,28 +1,28 @@
 import {
   lazy2
-} from "./location-mutation-88xbtdfr.js";
+} from "./worktree-88xbtdfr.js";
 import {
-  load4
-} from "./location-mutation-5qd3pb7m.js";
+  load3
+} from "./worktree-j935v87r.js";
 import {
   __export
-} from "./location-mutation-9rqn6x4v.js";
+} from "./worktree-9rqn6x4v.js";
 
 // src/filesystem/watcher.ts
 var exports_watcher = {};
 __export(exports_watcher, {
-  Event: () => Event17,
+  Event: () => Event9,
   Native: () => Native3,
-  Options: () => Options10,
-  Service: () => Service71,
+  Options: () => Options6,
+  Service: () => Service55,
   Test: () => Test3,
   Watcher: () => exports_watcher,
-  configured: () => configured11,
+  configured: () => configured7,
   hasNativeBinding: () => hasNativeBinding2,
-  layer: () => layer25,
+  layer: () => layer20,
   nativeLayer: () => nativeLayer2,
   nativeNode: () => nativeNode2,
-  node: () => node75,
+  node: () => node59,
   testLayer: () => testLayer3
 });
 import { createWrapper } from "@parcel/watcher/wrapper";
@@ -33,10 +33,10 @@ import { Cause, Context, Effect, Layer, PubSub, RcMap, Schema, Stream } from "ef
 import { watch } from "node:fs";
 import path from "path";
 var SUBSCRIBE_TIMEOUT_MS = 1e4;
-var Event17 = { Updated: FileSystem.Event.Changed };
+var Event9 = { Updated: FileSystem.Event.Changed };
 var watcher = lazy2(() => {
   try {
-    return createWrapper(load4());
+    return createWrapper(load3());
   } catch {
     return;
   }
@@ -53,18 +53,18 @@ var hasNativeBinding2 = () => !!watcher();
 
 class Native3 extends Context.Service()("@opencode/Watcher/Native") {
 }
-var Options10 = Schema.Struct({
+var Options6 = Schema.Struct({
   enabled: Schema.optional(Schema.Boolean)
 });
 
-class Service71 extends Context.Service()("@opencode/Watcher") {
+class Service55 extends Context.Service()("@opencode/Watcher") {
 }
 
 class Test3 extends Context.Service()("@opencode/Watcher/Test") {
 }
-var layer25 = (options) => Layer.effect(Service71, Effect.gen(function* () {
+var layer20 = (options) => Layer.effect(Service55, Effect.gen(function* () {
   if (options?.enabled === false) {
-    return Service71.of({ subscribe: () => Effect.succeed(Stream.empty) });
+    return Service55.of({ subscribe: () => Effect.succeed(Stream.empty) });
   }
   const native = yield* Native3;
   const watchers = yield* RcMap.make({
@@ -105,7 +105,7 @@ var layer25 = (options) => Layer.effect(Service71, Effect.gen(function* () {
       return Stream.fromSubscription(subscription);
     }));
   });
-  return Service71.of({ subscribe });
+  return Service55.of({ subscribe });
 }));
 var testLayer3 = Layer.effectContext(Effect.gen(function* () {
   const subscriptions = [];
@@ -129,9 +129,9 @@ var testLayer3 = Layer.effectContext(Effect.gen(function* () {
       };
     })
   });
-  const context = yield* Layer.build(layer25().pipe(Layer.provide(Layer.succeed(Native3, native))));
+  const context = yield* Layer.build(layer20().pipe(Layer.provide(Layer.succeed(Native3, native))));
   const test = Test3.of({
-    subscribe: Context.get(context, Service71).subscribe,
+    subscribe: Context.get(context, Service55).subscribe,
     emit: (update) => Effect.sync(() => {
       const target = path.resolve(update.path);
       active.forEach((matches, publish) => {
@@ -141,7 +141,7 @@ var testLayer3 = Layer.effectContext(Effect.gen(function* () {
     }),
     subscriptions: () => Effect.sync(() => [...subscriptions])
   });
-  return Context.empty().pipe(Context.add(Service71, test), Context.add(Test3, test));
+  return Context.empty().pipe(Context.add(Service55, test), Context.add(Test3, test));
 }));
 var nativeLayer2 = Layer.succeed(Native3, Native3.of({
   subscribe: (input) => {
@@ -164,10 +164,10 @@ var nativeLayer2 = Layer.succeed(Native3, Native3.of({
   }
 }));
 var nativeNode2 = makeGlobalNode({ service: Native3, layer: nativeLayer2, deps: [] });
-function configured11(options) {
-  return makeGlobalNode({ service: Service71, layer: layer25(options), deps: [nativeNode2] });
+function configured7(options) {
+  return makeGlobalNode({ service: Service55, layer: layer20(options), deps: [nativeNode2] });
 }
-var node75 = configured11();
+var node59 = configured7();
 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));
@@ -187,4 +187,4 @@ function subscribeDirectory(native, backend, directory, ignore, publish) {
   }).pipe(Effect.as(undefined))));
 }
 
-export { Event17, hasNativeBinding2, Native3, Options10, Service71, Test3, layer25, testLayer3, nativeLayer2, nativeNode2, configured11, node75, exports_watcher };
+export { Event9, hasNativeBinding2, Native3, Options6, Service55, Test3, layer20, testLayer3, nativeLayer2, nativeNode2, configured7, node59, exports_watcher };

package/dist/chunks/{location-mutation-jd8mn5p2.js → worktree-72ba6k3m.js}

@@ -1,28 +1,28 @@
 import {
   Service79,
-  node83
-} from "./location-mutation-ddbs5teb.js";
+  node84
+} from "./worktree-8xgxcjcn.js";
 import {
   Service76,
-  node80
-} from "./location-mutation-ext0y26q.js";
+  node81
+} from "./worktree-6hwsp9rp.js";
 import {
   SessionEvent2
-} from "./location-mutation-mntxs535.js";
+} from "./worktree-mntxs535.js";
 import {
-  Service65,
-  node68
-} from "./location-mutation-eepzdbxz.js";
+  Service72,
+  node77
+} from "./worktree-tbvm2gay.js";
 import {
   __export
-} from "./location-mutation-9rqn6x4v.js";
+} from "./worktree-9rqn6x4v.js";
 
 // src/session/instructions.ts
 var exports_instructions = {};
 __export(exports_instructions, {
-  Service: () => Service11,
+  Service: () => Service9,
   SessionInstructions: () => exports_instructions,
-  node: () => node13
+  node: () => node12
 });
 import { relative } from "path";
 import { Context, Effect, Layer, Option, Ref, Schema } from "effect";
@@ -32,12 +32,12 @@ var InjectedMetadata = Schema.Struct({
   instruction: Schema.Struct({ paths: Schema.Array(Schema.String) })
 });
 
-class Service11 extends Context.Service()("@opencode/SessionInstructions") {
+class Service9 extends Context.Service()("@opencode/SessionInstructions") {
 }
-var layer = Layer.effect(Service11, Effect.gen(function* () {
+var layer = Layer.effect(Service9, Effect.gen(function* () {
   const bus = yield* Service79;
   const fs = yield* FSUtil.Service;
-  const store = yield* Service65;
+  const store = yield* Service72;
   const location = yield* Service76;
   const root = yield* fs.resolve(location.project.directory);
   const inFlight = yield* Ref.make(new Map);
@@ -84,7 +84,7 @@ ${file.content}`).join(`
       return next;
     })));
   });
-  return Service11.of({ load });
+  return Service9.of({ load });
 }));
 function previouslyInjected(store, sessionID) {
   return Effect.gen(function* () {
@@ -95,10 +95,10 @@ function previouslyInjected(store, sessionID) {
 function describePath(root, path) {
   return FSUtil.contains(root, path) ? relative(root, path) : path;
 }
-var node13 = makeLocationNode({
+var node12 = makeLocationNode({
   name: "session-instructions",
   layer,
-  deps: [node83, FSUtil.node, node80, node68]
+  deps: [node84, FSUtil.node, node81, node77]
 });
 
-export { Service11, node13, exports_instructions };
+export { Service9, node12, exports_instructions };

package/dist/chunks/{location-mutation-7bmhse3q.js → worktree-7bmhse3q.js}

@@ -2,7 +2,7 @@ import {
   getTableColumnsRuntime2,
   orderSelectedFields2,
   mapUpdateSet2
-} from "./location-mutation-emrn6kk6.js";
+} from "./worktree-emrn6kk6.js";
 
 // src/database/drizzle/sqlite-core/effect/insert.ts
 import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";

package/dist/chunks/worktree-7cp4ry1k.js

@@ -0,0 +1,287 @@
+import {
+  AbsolutePath2
+} from "./worktree-p8qxwesx.js";
+import {
+  WorktreeError2,
+  node83
+} from "./worktree-xdga9zy9.js";
+import {
+  ID18
+} from "./worktree-xp0tb8fr.js";
+import {
+  Slug2
+} from "./worktree-gebd4c9n.js";
+import {
+  Service80,
+  node85
+} from "./worktree-y1a5hjjj.js";
+import {
+  Service79,
+  node84
+} from "./worktree-8xgxcjcn.js";
+import {
+  ProjectTable2
+} from "./worktree-qvbcabdc.js";
+import {
+  WorktreeTable2
+} from "./worktree-yg7sb877.js";
+import {
+  Service76,
+  node81
+} from "./worktree-6hwsp9rp.js";
+import {
+  DirectoryUnavailableError2,
+  canonical2
+} from "./worktree-hhpzk61m.js";
+import {
+  make19
+} from "./worktree-hzgckczr.js";
+import {
+  create3
+} from "./worktree-kg06axw8.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/worktree.ts
+var exports_worktree2 = {};
+__export(exports_worktree2, {
+  CreateInput: () => CreateInput3,
+  DestinationExistsError: () => DestinationExistsError2,
+  DirectoryUnavailableError: () => DirectoryUnavailableError2,
+  Event: () => Event16,
+  Info: () => Info25,
+  InvalidDirectoryError: () => InvalidDirectoryError2,
+  List: () => List2,
+  ListEntry: () => ListEntry3,
+  OperationError: () => OperationError2,
+  RefreshResult: () => RefreshResult2,
+  RemoveInput: () => RemoveInput2,
+  Service: () => Service67,
+  SourceDirectoryNotFoundError: () => SourceDirectoryNotFoundError2,
+  StrategyID: () => StrategyID2,
+  StrategyUnavailableError: () => StrategyUnavailableError2,
+  UnsupportedLocationError: () => UnsupportedLocationError2,
+  Worktree: () => exports_worktree2,
+  node: () => node72
+});
+import { Context, Effect, Layer, Schema } from "effect";
+import { and, asc, desc, eq, isNull, sql } from "drizzle-orm";
+import path from "path";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Global } from "@opencode-ai/util/global";
+import { Worktree } from "@opencode-ai/schema/worktree";
+import { AppProcess } from "@opencode-ai/util/process";
+import { ChildProcess } from "effect/unstable/process";
+import { OperationError as OperationError2 } from "@opencode-ai/schema/worktree";
+var StrategyID2 = Worktree.StrategyID;
+var CreateInput3 = Worktree.CreateInput;
+var RemoveInput2 = Worktree.RemoveInput;
+var RefreshResult2 = Schema.Struct({
+  updated: Schema.Array(AbsolutePath2),
+  removed: Schema.Array(AbsolutePath2)
+}).annotate({ identifier: "Worktree.RefreshResult" });
+var Info25 = Worktree.Info;
+var List2 = Worktree.List;
+var ListEntry3 = Worktree.ListEntry;
+
+class SourceDirectoryNotFoundError2 extends Schema.TaggedError()("Worktree.SourceDirectoryNotFoundError", { projectID: ID18, directory: Schema.optional(AbsolutePath2) }) {
+}
+
+class DestinationExistsError2 extends Schema.TaggedError()("Worktree.DestinationExistsError", { directory: AbsolutePath2 }) {
+}
+
+class InvalidDirectoryError2 extends Schema.TaggedError()("Worktree.InvalidDirectoryError", { directory: AbsolutePath2 }) {
+}
+
+class StrategyUnavailableError2 extends Schema.TaggedError()("Worktree.StrategyUnavailableError", { strategy: StrategyID2 }) {
+}
+
+class UnsupportedLocationError2 extends Schema.TaggedError()("Worktree.UnsupportedLocationError", { directory: AbsolutePath2 }) {
+}
+var Event16 = Worktree.Event;
+
+class Service67 extends Context.Service()("@opencode/v2/Worktree") {
+}
+var layer = Layer.effect(Service67, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const database = yield* Service80;
+  const db = database.db;
+  const bus = yield* Service79;
+  const processService = yield* AppProcess.Service;
+  const location = yield* Service76;
+  const global = yield* Global.Service;
+  const projectID = location.project.id;
+  const local = location.workspaceID ? Effect.fail(new UnsupportedLocationError2({ directory: location.directory })) : Effect.void;
+  const gitStrategy = yield* make19;
+  const state = create3({
+    name: "worktree",
+    initial: () => ({
+      directory: AbsolutePath2.make(path.join(global.data, "worktree", projectID.slice(0, 6))),
+      strategies: new Map([[gitStrategy.id, gitStrategy]]),
+      selected: gitStrategy.id
+    }),
+    editor: (value) => ({
+      configure: (settings) => {
+        value.directory = settings.directory;
+      },
+      add: (strategy) => {
+        value.strategies.delete(strategy.id);
+        value.strategies.set(strategy.id, strategy);
+        value.selected = strategy.id;
+      }
+    })
+  });
+  const changed = Effect.fnUntraced(function* (update) {
+    if (update)
+      yield* bus.publish(Event16.Updated, { projectID });
+  });
+  const ops = {
+    list: Effect.fnUntraced(function* () {
+      const rows = yield* db.select({ directory: WorktreeTable2.directory, strategy: WorktreeTable2.strategy }).from(WorktreeTable2).where(eq(WorktreeTable2.project_id, projectID)).orderBy(desc(WorktreeTable2.time_created), asc(WorktreeTable2.directory)).all().pipe(Effect.orDie);
+      return rows.map((row) => ({ directory: row.directory, strategy: row.strategy ?? undefined }));
+    }),
+    find: Effect.fnUntraced(function* (directory) {
+      const row = yield* db.select({ directory: WorktreeTable2.directory, strategy: WorktreeTable2.strategy }).from(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, projectID), eq(WorktreeTable2.directory, directory))).get().pipe(Effect.orDie);
+      return row ? { directory: row.directory, strategy: row.strategy ?? undefined } : undefined;
+    }),
+    create: (input, tx) => (tx ?? db).insert(WorktreeTable2).values({
+      project_id: projectID,
+      directory: input.directory,
+      strategy: input.strategy
+    }).onConflictDoUpdate({
+      target: [WorktreeTable2.project_id, WorktreeTable2.directory],
+      set: {
+        strategy: input.strategy ?? null
+      },
+      setWhere: input.replace ? undefined : input.strategy ? isNull(WorktreeTable2.strategy) : sql`false`
+    }).returning({ directory: WorktreeTable2.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined)),
+    remove: (directory, tx) => (tx ?? db).delete(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, projectID), eq(WorktreeTable2.directory, directory))).returning({ directory: WorktreeTable2.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined))
+  };
+  const source = Effect.fnUntraced(function* (input) {
+    const sourceDirectory = input ?? location.project.directory;
+    const resolved = yield* canonical2(fs, sourceDirectory);
+    if ((yield* ops.find(resolved)) === undefined)
+      return yield* new SourceDirectoryNotFoundError2({ projectID, directory: resolved });
+    return resolved;
+  });
+  const getStrategy = Effect.fnUntraced(function* (id, strategies) {
+    const found = strategies.get(id);
+    if (!found)
+      return yield* new StrategyUnavailableError2({ strategy: id });
+    return found;
+  });
+  const create = Effect.fn("Worktree.create")(function* (input = {}) {
+    yield* local;
+    const current = state.get();
+    const selected = yield* getStrategy(input.strategy ?? current.selected, current.strategies);
+    const directory = input.directory ?? current.directory;
+    const sourceDirectory = yield* source(input.from);
+    yield* fs.makeDirectory(directory, { recursive: true }).pipe(Effect.orDie);
+    const name = input.name ?? Slug2.create();
+    let suffix = 1;
+    let worktreeDirectory = AbsolutePath2.make(path.join(directory, name));
+    while (yield* fs.existsSafe(worktreeDirectory)) {
+      suffix++;
+      if (suffix > 10)
+        return yield* new DestinationExistsError2({ directory: worktreeDirectory });
+      worktreeDirectory = AbsolutePath2.make(path.join(directory, `${name}-${suffix}`));
+    }
+    const created = yield* selected.create({
+      directory: worktreeDirectory,
+      sourceDirectory,
+      branch: input.branch
+    }).pipe(Effect.mapError((error) => operationError(selected.id, "create", error)));
+    const result = { directory: yield* canonical2(fs, created.directory) };
+    if (result.directory !== (yield* canonical2(fs, worktreeDirectory)))
+      return yield* new InvalidDirectoryError2({ directory: result.directory });
+    yield* changed(yield* ops.create({
+      directory: result.directory,
+      strategy: selected.id,
+      replace: true
+    }));
+    const project = yield* db.select({ commands: ProjectTable2.commands }).from(ProjectTable2).where(eq(ProjectTable2.id, projectID)).get().pipe(Effect.orDie);
+    const command = project?.commands?.start?.trim();
+    if (command) {
+      const windows = process.platform === "win32";
+      yield* processService.run(ChildProcess.make(windows ? command : "bash", windows ? [] : ["-lc", command], {
+        cwd: result.directory,
+        env: {
+          OPENCODE_WORKTREE_BASE: sourceDirectory,
+          OPENCODE_WORKTREE_PATH: result.directory
+        },
+        extendEnv: true,
+        stdin: "ignore",
+        shell: windows
+      })).pipe(Effect.flatMap(AppProcess.requireSuccess));
+    }
+    return result;
+  });
+  const remove = Effect.fn("Worktree.remove")(function* (input) {
+    yield* local;
+    const worktreeDirectory = yield* canonical2(fs, input.directory);
+    const stored = yield* ops.find(worktreeDirectory);
+    if (!stored?.strategy)
+      return yield* new InvalidDirectoryError2({ directory: worktreeDirectory });
+    const strategy = yield* getStrategy(StrategyID2.make(stored.strategy), state.get().strategies);
+    yield* strategy.remove({
+      directory: worktreeDirectory,
+      force: input.force
+    }).pipe(Effect.mapError((error) => operationError(strategy.id, "remove", error)));
+    yield* changed(yield* ops.remove(worktreeDirectory));
+  });
+  const refresh = Effect.fn("Worktree.refresh")(function* () {
+    yield* local;
+    const stored = yield* ops.list();
+    const checked = yield* Effect.forEach(stored, (item) => fs.isDir(item.directory).pipe(Effect.map((exists) => ({ ...item, exists }))), { concurrency: "unbounded" });
+    const strategies = Array.from(state.get().strategies.values()).toReversed();
+    const discovered = new Map;
+    if (checked.some((item) => item.directory === location.project.directory && item.exists)) {
+      for (const strategy of strategies) {
+        const entries = yield* strategy.list(location.project.directory).pipe(Effect.mapError((error) => operationError(strategy.id, "list", error)), Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.succeed([])));
+        for (const entry of entries) {
+          const directory = yield* canonical2(fs, entry.directory).pipe(Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.undefined));
+          if (!directory || discovered.has(directory))
+            continue;
+          discovered.set(directory, {
+            directory,
+            strategy: entry.type === "worktree" ? strategy.id : undefined
+          });
+        }
+      }
+    }
+    const removed = checked.filter((item) => !item.exists).map((item) => item.directory);
+    const changes = yield* db.transaction((tx) => Effect.all({
+      updated: Effect.filter(Array.from(discovered.values()), (item) => ops.create(item, tx)).pipe(Effect.map((items) => items.map((item) => item.directory))),
+      removed: Effect.filter(removed, (directory) => ops.remove(directory, tx))
+    })).pipe(Effect.orDie);
+    yield* changed(changes.updated.length > 0 || changes.removed.length > 0);
+    return changes;
+  });
+  return Service67.of({
+    transform: state.transform,
+    reload: state.reload,
+    list: Effect.fn("Worktree.list")(function* () {
+      yield* refresh();
+      return yield* ops.list();
+    }),
+    create,
+    remove,
+    refresh
+  });
+}));
+var node72 = makeLocationNode({
+  service: Service67,
+  layer,
+  deps: [FSUtil.node, node83, node84, node85, AppProcess.node, node81, Global.node]
+});
+function operationError(strategy, operation, error) {
+  if (error instanceof WorktreeError2 || error instanceof DirectoryUnavailableError2 || error instanceof Worktree.OperationError)
+    return error;
+  return new Worktree.OperationError({
+    message: `Worktree strategy ${strategy} failed to ${operation}: ${error instanceof globalThis.Error ? error.message : String(error)}`
+  });
+}
+
+export { StrategyID2, CreateInput3, RemoveInput2, RefreshResult2, Info25, List2, ListEntry3, SourceDirectoryNotFoundError2, DestinationExistsError2, InvalidDirectoryError2, StrategyUnavailableError2, UnsupportedLocationError2, Event16, Service67, node72, exports_worktree2, OperationError2 };