@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-9nbw7tbd.js

@@ -0,0 +1,206 @@
+import {
+  exports_permission
+} from "./location-mutation-gjaba53s.js";
+import {
+  exports_websearch
+} from "./location-mutation-9m1tawx7.js";
+import {
+  exports_config
+} from "./location-mutation-qvf5nvg0.js";
+import {
+  exports_form
+} from "./location-mutation-w6yb7hdq.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/tool/plugin/websearch.ts
+var exports_websearch2 = {};
+__export(exports_websearch2, {
+  name: () => name,
+  description: () => description,
+  WebSearchTool: () => exports_websearch2,
+  Plugin: () => Plugin,
+  NO_RESULTS: () => NO_RESULTS,
+  Input: () => Input
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { Effect, Schema, Semaphore } from "effect";
+import { HttpClientError } from "effect/unstable/http";
+var name = "websearch";
+var NO_RESULTS = "No search results found. Please try a different query.";
+var providerSelectionLock = Semaphore.makeUnsafe(1);
+var description = `Search the web using the user's selected search integration. Use this for current information beyond knowledge cutoff.
+
+The current year is ${new Date().getFullYear()}. Use this year when searching for recent information or current events.`;
+var Input = Schema.Struct({
+  query: Schema.String.annotate({ description: "Websearch query" })
+});
+var Output = Schema.Struct({
+  provider: exports_websearch.ID,
+  results: Schema.Array(exports_websearch.Result)
+});
+var Plugin = {
+  id: "opencode.tool.websearch",
+  effect: Effect.fn("WebSearchTool.Plugin")(function* (ctx) {
+    const permission = yield* exports_permission.Service;
+    const forms = yield* exports_form.Service;
+    const config = yield* exports_config.Service;
+    const websearch = yield* exports_websearch.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false },
+      description,
+      input: Input,
+      output: Output,
+      execute: (input, context) => Effect.gen(function* () {
+        yield* permission.assert({
+          action: name,
+          resources: [input.query],
+          save: ["*"],
+          metadata: input,
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source: { type: "tool", messageID: context.messageID, id: context.id }
+        });
+        const search = () => websearch.default().pipe(Effect.flatMap((provider) => {
+          if (!provider)
+            return ctx.websearch.query(input);
+          return context.progress({ provider: provider.id }).pipe(Effect.andThen(ctx.websearch.query({ ...input, providerID: provider.id })));
+        }), Effect.catch((error) => {
+          if (!Schema.is(exports_websearch.ProviderRequiredError)(error))
+            return Effect.fail(error);
+          return providerSelectionLock.withPermit(Effect.gen(function* () {
+            if (yield* websearch.default())
+              return;
+            const providers = (yield* ctx.websearch.providers()).data;
+            const defaultProvider = providers[0];
+            if (!defaultProvider)
+              return yield* new exports_websearch.ProviderRequiredError;
+            const response = yield* forms.ask({
+              sessionID: context.sessionID,
+              title: "Web Search",
+              metadata: { kind: "websearch.provider" },
+              fields: [
+                {
+                  key: "choice",
+                  description: "Allow OpenCode to search the web for up-to-date information?",
+                  type: "string",
+                  required: true,
+                  custom: false,
+                  options: [
+                    {
+                      value: "allow",
+                      label: `Allow search via ${providers.map((provider) => provider.name).join(", ")}`
+                    },
+                    {
+                      value: "choose",
+                      label: "Choose another provider"
+                    },
+                    { value: "disable", label: "Disable web search" }
+                  ]
+                }
+              ]
+            });
+            if (response.status === "cancelled")
+              return yield* Effect.fail(new Error("Web search cancelled"));
+            if (response.answer.choice === "disable") {
+              yield* config.update((draft2) => {
+                draft2.websearch = false;
+              });
+              return yield* new exports_websearch.DisabledError;
+            }
+            const selection = response.answer.choice === "choose" ? yield* forms.ask({
+              sessionID: context.sessionID,
+              title: "Choose a web search provider",
+              metadata: { kind: "websearch.provider" },
+              fields: [
+                {
+                  key: "provider",
+                  description: "Choose a provider for web search.",
+                  type: "string",
+                  required: true,
+                  custom: false,
+                  options: providers.map((provider) => ({
+                    value: provider.id,
+                    label: provider.name
+                  }))
+                }
+              ]
+            }) : undefined;
+            if (selection?.status === "cancelled")
+              return yield* Effect.fail(new Error("Web search cancelled"));
+            const providerID = selection?.answer.provider ?? "random";
+            if (typeof providerID !== "string" || providerID !== "random" && !providers.some((provider) => provider.id === providerID))
+              return yield* new exports_websearch.ProviderRequiredError;
+            yield* config.update((draft2) => {
+              draft2.websearch = {
+                provider: providerID === "random" ? "random" : exports_websearch.ID.make(providerID)
+              };
+            });
+            if (providerID !== "random")
+              return exports_websearch.ID.make(providerID);
+            return providers[Math.floor(Math.random() * providers.length)]?.id;
+          })).pipe(Effect.timeoutOrElse({
+            duration: "1 minute",
+            orElse: () => Effect.fail(new Error("Web search cancelled"))
+          }), Effect.flatMap((providerID) => {
+            if (!providerID)
+              return Effect.suspend(search);
+            return context.progress({ provider: providerID }).pipe(Effect.andThen(ctx.websearch.query({ ...input, providerID })));
+          }));
+        }));
+        const result = yield* search();
+        const output = {
+          provider: result.data.providerID,
+          results: result.data.results
+        };
+        const content = output.results.length ? output.results.map((result2) => {
+          const title = result2.title ?? result2.url;
+          const published = result2.time.published ? `
+Published: ${new Date(result2.time.published).toISOString()}` : "";
+          return `## [${title}](${result2.url})${published}${result2.content ? `
+
+${result2.content}` : ""}`;
+        }).join(`
+
+`) : NO_RESULTS;
+        return { output, content, metadata: { provider: output.provider } };
+      }).pipe(Effect.mapError((error) => {
+        const fallback = `Unable to search the web for ${input.query}`;
+        if (!Schema.is(exports_websearch.RequestError)(error))
+          return new ToolFailure({ message: fallback, error });
+        const status = HttpClientError.isHttpClientError(error.cause) ? error.cause.response?.status : undefined;
+        switch (status) {
+          case 429:
+            return new ToolFailure({
+              message: "Web search rate limited (HTTP 429)",
+              error,
+              metadata: { provider: error.providerID }
+            });
+          case 401:
+            return new ToolFailure({
+              message: "Web search authentication failed (HTTP 401)",
+              error,
+              metadata: { provider: error.providerID }
+            });
+          case undefined:
+            return new ToolFailure({ message: fallback, error, metadata: { provider: error.providerID } });
+          default:
+            return new ToolFailure({
+              message: `Web search request failed (HTTP ${status})`,
+              error,
+              metadata: { provider: error.providerID }
+            });
+        }
+      }))
+    })).pipe(Effect.orDie);
+    yield* ctx.session.hook("context", (event) => Effect.gen(function* () {
+      const disabled = exports_config.latest(yield* config.entries(), "websearch") === false;
+      if (disabled)
+        delete event.tools[name];
+    }));
+  })
+};
+
+export { name, NO_RESULTS, description, Input, Plugin, exports_websearch2 as exports_websearch };

package/dist/chunks/location-mutation-9r0qzhnf.js

@@ -0,0 +1,34 @@
+import {
+  exports_provider
+} from "./location-mutation-d6vvk673.js";
+import {
+  __require
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin/provider/vercel.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var VercelPlugin = define({
+  id: "opencode.provider.vercel",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!exports_provider.isAISDK(item.provider.package))
+          continue;
+        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/vercel")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = { ...provider.headers, "http-referer": "https://opencode.ai/", "x-title": "opencode" };
+        });
+      }
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.package !== "@ai-sdk/vercel")
+        return;
+      const mod = yield* Effect.promise(() => import("@ai-sdk/vercel"));
+      evt.sdk = mod.createVercel(evt.options);
+    }));
+  })
+});
+
+export { VercelPlugin };

package/dist/chunks/location-mutation-9sdtsapf.js

@@ -0,0 +1,30 @@
+// src/database/migration/20260427172553_slow_nightmare.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260427172553_slow_nightmare",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`session_message\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`data\` text NOT NULL,
+          CONSTRAINT \`fk_session_message_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_entry_session_idx\`;`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_entry_session_type_idx\`;`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_entry_time_created_idx\`;`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_idx\` ON \`session_message\` (\`session_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_type_idx\` ON \`session_message\` (\`session_id\`,\`type\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_time_created_idx\` ON \`session_message\` (\`time_created\`);`);
+      yield* tx.run(`DROP TABLE \`session_entry\`;`);
+    });
+  }
+};
+var _20260427172553_slow_nightmare_default = migration;
+
+export { _20260427172553_slow_nightmare_default };

package/dist/chunks/location-mutation-9xe9cxt1.js

@@ -0,0 +1,88 @@
+import {
+  exports_store
+} from "./location-mutation-qea62gnn.js";
+import {
+  SessionEvent
+} from "./location-mutation-a83yvq99.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/session/instructions.ts
+var exports_instructions = {};
+__export(exports_instructions, {
+  node: () => node,
+  SessionInstructions: () => exports_instructions,
+  Service: () => Service
+});
+import { relative } from "path";
+import { Context, Effect, Layer, Option, Ref, Schema } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+var InjectedMetadata = Schema.Struct({
+  instruction: Schema.Struct({ paths: Schema.Array(Schema.String) })
+});
+
+class Service extends Context.Service()("@opencode/SessionInstructions") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const fs = yield* FSUtil.Service;
+  const store = yield* exports_store.Service;
+  const location = yield* exports_location.Service;
+  const root = yield* fs.resolve(location.project.directory);
+  const injected = yield* Ref.make(new Map);
+  const load = Effect.fn("SessionInstructions.load")(function* (input) {
+    const claimed = yield* Ref.modify(injected, (map) => {
+      const existing = map.get(input.sessionID) ?? new Set;
+      const newlyClaimed = input.paths.filter((path) => !existing.has(path));
+      if (newlyClaimed.length === 0)
+        return [newlyClaimed, map];
+      const next = new Map(map);
+      next.set(input.sessionID, new Set([...existing, ...newlyClaimed]));
+      return [newlyClaimed, next];
+    });
+    if (claimed.length === 0)
+      return;
+    const alreadyInjected = yield* previouslyInjected(store, input.sessionID);
+    const toInject = claimed.filter((path) => !alreadyInjected.has(path));
+    if (toInject.length === 0)
+      return;
+    const files = yield* Effect.forEach(toInject, (path) => fs.readFileStringSafe(path).pipe(Effect.map((content) => content === undefined ? undefined : { path, content })), { concurrency: "unbounded" });
+    const readable = files.filter((file) => file !== undefined);
+    if (readable.length === 0)
+      return;
+    yield* bus.publish(SessionEvent.Synthetic, {
+      sessionID: input.sessionID,
+      text: readable.map((file) => `Instructions from: ${file.path}
+${file.content}`).join(`
+
+`),
+      description: `Loaded ${readable.map((file) => describePath(root, file.path)).join(", ")}`,
+      metadata: { instruction: { paths: readable.map((file) => file.path) } }
+    });
+  });
+  return Service.of({ load });
+}));
+function previouslyInjected(store, sessionID) {
+  return Effect.gen(function* () {
+    const history = yield* store.context(sessionID);
+    return new Set(history.filter((message) => message.type === "synthetic").flatMap((message) => Option.getOrUndefined(Schema.decodeUnknownOption(InjectedMetadata)(message.metadata))?.instruction.paths ?? []));
+  });
+}
+function describePath(root, path) {
+  return FSUtil.contains(root, path) ? relative(root, path) : path;
+}
+var node = makeLocationNode({
+  name: "session-instructions",
+  layer,
+  deps: [exports_bus.node, FSUtil.node, exports_location.node, exports_store.node]
+});
+
+export { Service, node, exports_instructions };

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

@@ -0,0 +1,10 @@
+// src/github-copilot/chat/openai-compatible-chat-options.ts
+import { z } from "zod/v4";
+var openaiCompatibleProviderOptions = z.object({
+  user: z.string().optional(),
+  reasoningEffort: z.string().optional(),
+  textVerbosity: z.string().optional(),
+  thinking_budget: z.number().optional()
+});
+
+export { openaiCompatibleProviderOptions };

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

@@ -0,0 +1,155 @@
+import {
+  AbsolutePath
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/skill/discovery.ts
+var exports_discovery = {};
+__export(exports_discovery, {
+  node: () => node,
+  SkillDiscovery: () => exports_discovery,
+  Service: () => Service
+});
+import path from "path";
+import { Context, Effect, Layer, Schedule, Schema } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Global } from "@opencode-ai/util/global";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { httpClient } from "@opencode-ai/util/effect/app-node-platform";
+import { Hash } from "@opencode-ai/util/hash";
+var skillConcurrency = 4;
+var fileConcurrency = 8;
+function isSafeSegment(value) {
+  return value.length > 0 && value !== "." && value !== ".." && !value.includes("/") && !value.includes("\\") && !value.includes("\x00");
+}
+function isSafeRelativePath(value) {
+  const segments = value.split("/");
+  return value.length > 0 && !value.includes("\\") && !value.includes("\x00") && !value.includes("?") && !value.includes("#") && !URL.canParse(value) && !path.posix.isAbsolute(value) && !path.win32.isAbsolute(value) && segments.every((segment) => {
+    try {
+      const decoded = decodeURIComponent(segment);
+      return decoded.length > 0 && decoded !== "." && decoded !== ".." && !decoded.includes("/") && !decoded.includes("\\") && !decoded.includes("\x00");
+    } catch {
+      return false;
+    }
+  });
+}
+
+class IndexSkill extends Schema.Class("SkillDiscovery.IndexSkill")({
+  name: Schema.String,
+  version: Schema.optional(Schema.String),
+  files: Schema.Array(Schema.String)
+}) {
+}
+
+class Index extends Schema.Class("SkillDiscovery.Index")({
+  skills: Schema.Array(IndexSkill)
+}) {
+}
+
+class Service extends Context.Service()("@opencode/SkillDiscovery") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const http = (yield* HttpClient.HttpClient).pipe(HttpClient.retryTransient({
+    retryOn: "errors-and-responses",
+    times: 2,
+    schedule: Schedule.exponential(200).pipe(Schedule.jittered)
+  }), HttpClient.filterStatusOk);
+  const download = Effect.fn("SkillDiscovery.download")(function* (url, destination) {
+    if (yield* fs.exists(destination).pipe(Effect.orDie))
+      return true;
+    return yield* HttpClientRequest.get(url).pipe(http.execute, Effect.flatMap((response) => response.arrayBuffer), Effect.flatMap((body) => fs.writeWithDirs(destination, new Uint8Array(body))), Effect.as(true), Effect.catch((error) => Effect.logError("failed to download skill file", { url, error }).pipe(Effect.as(false))));
+  });
+  return Service.of({
+    pull: Effect.fn("SkillDiscovery.pull")(function* (url) {
+      const base = url.endsWith("/") ? url : `${url}/`;
+      const source = new URL(base);
+      const index = new URL("index.json", source).href;
+      const data = yield* HttpClientRequest.get(index).pipe(HttpClientRequest.acceptJson, http.execute, Effect.flatMap(HttpClientResponse.schemaBodyJson(Index)), Effect.catch((error) => Effect.logError("failed to fetch skill index", { url: index, error }).pipe(Effect.as(undefined))));
+      if (!data)
+        return [];
+      const sourceRoot = path.resolve(global.cache, "skills", Hash.fast(base));
+      return yield* Effect.forEach(data.skills.flatMap((skill) => {
+        if (!isSafeSegment(skill.name)) {
+          return [];
+        }
+        if (!skill.files.includes("SKILL.md") && !skill.files.includes(`${skill.name}.md`)) {
+          return [];
+        }
+        const root = path.resolve(sourceRoot, skill.name);
+        if (!FSUtil.contains(sourceRoot, root) || root === sourceRoot) {
+          return [];
+        }
+        const skillUrl = new URL(`${encodeURIComponent(skill.name)}/`, source);
+        const versionFile = path.join(root, ".opencode-version");
+        const files = skill.files.map((file) => {
+          if (!isSafeRelativePath(file))
+            return;
+          let resource;
+          try {
+            resource = new URL(file, skillUrl);
+          } catch {
+            return;
+          }
+          if (resource.origin !== source.origin)
+            return;
+          const destination = path.resolve(root, file);
+          if (!FSUtil.contains(root, destination) || destination === root)
+            return;
+          return {
+            url: resource.href,
+            destination,
+            file
+          };
+        });
+        if (files.some((file) => file === undefined)) {
+          return [];
+        }
+        return [{ skill, root, versionFile, files }];
+      }), ({ skill, root, versionFile, files }) => Effect.gen(function* () {
+        const version = skill.version;
+        const current = version === undefined ? undefined : yield* fs.readFileStringSafe(versionFile).pipe(Effect.catch(() => Effect.succeed(undefined)));
+        if (version === undefined || current === version) {
+          yield* Effect.forEach(files, (file) => download(file.url, file.destination), {
+            concurrency: fileConcurrency,
+            discard: true
+          });
+        } else {
+          const token = crypto.randomUUID();
+          const staging = `${root}.tmp-${token}`;
+          const backup = `${root}.old-${token}`;
+          yield* Effect.gen(function* () {
+            const downloaded = yield* Effect.forEach(files, (file) => download(file.url, path.resolve(staging, file.file)), { concurrency: fileConcurrency });
+            if (!downloaded.every(Boolean))
+              return;
+            const exists2 = (yield* fs.exists(path.join(staging, "SKILL.md")).pipe(Effect.orDie)) || (yield* fs.exists(path.join(staging, `${skill.name}.md`)).pipe(Effect.orDie));
+            if (!exists2)
+              return;
+            yield* fs.writeFileString(path.join(staging, ".opencode-version"), version);
+            yield* Effect.uninterruptible(Effect.gen(function* () {
+              const cached = yield* fs.exists(root).pipe(Effect.orDie);
+              if (cached)
+                yield* fs.rename(root, backup);
+              yield* fs.rename(staging, root).pipe(Effect.catch((error) => Effect.gen(function* () {
+                if (cached)
+                  yield* fs.rename(backup, root).pipe(Effect.ignore);
+                return yield* Effect.fail(error);
+              })));
+              if (cached)
+                yield* fs.remove(backup, { recursive: true, force: true }).pipe(Effect.ignore);
+            }));
+          }).pipe(Effect.catch((error) => Effect.logError("failed to refresh skill", { skill: skill.name, error })), Effect.ensuring(fs.remove(staging, { recursive: true, force: true }).pipe(Effect.ignore)));
+        }
+        const exists = (yield* fs.exists(path.join(root, "SKILL.md")).pipe(Effect.orDie)) || (yield* fs.exists(path.join(root, `${skill.name}.md`)).pipe(Effect.orDie));
+        return exists ? [AbsolutePath.make(root)] : [];
+      }), { concurrency: skillConcurrency }).pipe(Effect.map((directories) => directories.flat()));
+    })
+  });
+}));
+var node = makeGlobalNode({ service: Service, layer, deps: [httpClient, FSUtil.node, Global.node] });
+
+export { Service, node, exports_discovery };

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

@@ -0,0 +1,151 @@
+import {
+  exports_config
+} from "./location-mutation-qvf5nvg0.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  exports_git
+} from "./location-mutation-kcwh27nh.js";
+import {
+  AbsolutePath,
+  RelativePath
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/snapshot.ts
+var exports_snapshot = {};
+__export(exports_snapshot, {
+  noopLayer: () => noopLayer,
+  node: () => node,
+  Snapshot: () => exports_snapshot,
+  Service: () => Service,
+  ID: () => ID,
+  Error: () => Error
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import path from "path";
+import { Context, Effect, Fiber, Layer, Schema, Scope } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Global } from "@opencode-ai/util/global";
+import { ID } from "@opencode-ai/schema/snapshot";
+import { Hash } from "@opencode-ai/util/hash";
+class Error extends Schema.TaggedErrorClass()("Snapshot.Error", {
+  operation: Schema.Literals(["capture", "files", "diff", "restore"]),
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect())
+}) {
+}
+
+class Service extends Context.Service()("@opencode/Snapshot") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const config = yield* exports_config.Service;
+  const fs = yield* FSUtil.Service;
+  const git = yield* exports_git.Service;
+  const global = yield* Global.Service;
+  const location = yield* exports_location.Service;
+  const lifetime = yield* Scope.Scope;
+  const repositoryFiber = yield* Effect.cached(Effect.gen(function* () {
+    const source = yield* git.repo.discover(location.project.directory);
+    if (!source)
+      return yield* new Error({ operation: "capture", message: "Project is not a Git repository" });
+    const worktree = AbsolutePath.make(yield* fs.realPath(source.worktree).pipe(Effect.orDie));
+    const gitDirectory = AbsolutePath.make(path.join(global.data, "snapshot", location.project.id, Hash.fast(worktree)));
+    const snapshotRepository = (yield* fs.existsSafe(path.join(gitDirectory, "HEAD"))) ? new exports_git.Repository({ worktree, gitDirectory, commonDirectory: gitDirectory }) : yield* git.repo.create({ worktree, gitDirectory, seed: source }).pipe(Effect.mapError((cause) => failure("capture", cause)));
+    return { source, worktree, snapshotRepository };
+  }).pipe(Effect.forkIn(lifetime)));
+  const repository = repositoryFiber.pipe(Effect.uninterruptible, Effect.flatMap(Fiber.join));
+  const scope = Effect.fnUntraced(function* (worktree) {
+    const relative = path.relative(worktree, location.directory);
+    if (relative.startsWith("..") || path.isAbsolute(relative))
+      return yield* new Error({ operation: "capture", message: "Location is outside the project" });
+    return RelativePath.make(relative.replaceAll("\\", "/") || ".");
+  });
+  const enabled = Effect.fnUntraced(function* () {
+    if (location.vcs?.type !== "git")
+      return false;
+    return exports_config.latest(yield* config.entries(), "snapshots") !== false;
+  });
+  const capture = Effect.fn("Snapshot.capture")(function* () {
+    if (!(yield* enabled()))
+      return;
+    return yield* Effect.gen(function* () {
+      const repo = yield* repository;
+      return ID.make(yield* git.tree.capture({
+        repository: repo.snapshotRepository,
+        scopes: [yield* scope(repo.worktree)],
+        ignores: repo.source,
+        maximumUntrackedFileBytes: 2 * 1024 * 1024
+      }));
+    }).pipe(Effect.catch((cause) => Effect.logWarning("failed to capture snapshot", { cause }).pipe(Effect.as(undefined))));
+  });
+  const compare = Effect.fnUntraced(function* (operation, input) {
+    const repo = yield* repository.pipe(Effect.mapError((cause) => failure(operation, cause)));
+    return {
+      source: repo.source,
+      input: {
+        repository: repo.snapshotRepository,
+        from: exports_git.TreeID.make(input.from),
+        to: exports_git.TreeID.make(input.to)
+      }
+    };
+  });
+  const files = Effect.fn("Snapshot.files")(function* (input) {
+    const comparison = yield* compare("files", input);
+    const files2 = yield* git.tree.files(comparison.input).pipe(Effect.mapError((cause) => failure("files", cause)));
+    const ignored = yield* git.index.ignored({ repository: comparison.source, paths: files2 }).pipe(Effect.mapError((cause) => failure("files", cause)));
+    return files2.filter((file) => !ignored.has(file));
+  });
+  const diff = Effect.fn("Snapshot.diff")(function* (input) {
+    const comparison = yield* compare("diff", input);
+    const files2 = yield* git.tree.files(comparison.input).pipe(Effect.mapError((cause) => failure("diff", cause)));
+    const ignored = yield* git.index.ignored({ repository: comparison.source, paths: files2 }).pipe(Effect.mapError((cause) => failure("diff", cause)));
+    return yield* git.tree.diff({
+      ...comparison.input,
+      context: input.context,
+      paths: (input.paths ?? files2).filter((file) => !ignored.has(file))
+    }).pipe(Effect.mapError((cause) => failure("diff", cause)));
+  });
+  const plan = Effect.fnUntraced(function* (worktree, input) {
+    const files2 = new Map;
+    for (const [file, snapshot] of input.files) {
+      const absolute = path.resolve(worktree, file);
+      if (!FSUtil.contains(worktree, absolute))
+        return yield* new Error({ operation: "restore", message: `Path escapes the project: ${file}` });
+      files2.set(file, exports_git.TreeID.make(snapshot));
+    }
+    return files2;
+  });
+  const restore = Effect.fn("Snapshot.restore")(function* (input) {
+    if (!(yield* enabled()))
+      return yield* new Error({ operation: "restore", message: "Snapshots are disabled" });
+    const repo = yield* repository.pipe(Effect.mapError((cause) => failure("restore", cause)));
+    yield* git.tree.restore({ repository: repo.snapshotRepository, files: yield* plan(repo.worktree, input) }).pipe(Effect.mapError((cause) => failure("restore", cause)));
+  });
+  return Service.of({ capture, files, diff, restore });
+}).pipe(Effect.withSpan("Snapshot.boot")));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_config.node, FSUtil.node, exports_git.node, Global.node, exports_location.node]
+});
+var noopLayer = Layer.succeed(Service, Service.of({
+  capture: () => Effect.succeed(undefined),
+  files: () => Effect.succeed([]),
+  diff: () => Effect.succeed([]),
+  restore: () => Effect.void
+}));
+function failure(operation, cause) {
+  if (cause instanceof Error && cause.operation === operation)
+    return cause;
+  return new Error({
+    operation,
+    message: cause instanceof globalThis.Error ? cause.message : String(cause),
+    cause
+  });
+}
+
+export { ID, Error, Service, node, noopLayer, exports_snapshot };