@opencode-ai/core 0.0.0-beta-19086 → 0.0.0-beta-19124

package/dist/chunks/{schema-43f3kvve.js → event-logger-j2sh7cb4.js}

@@ -1,15 +1,15 @@
 import {
-  exports_permission
-} from "./schema-1nf5m1zv.js";
+  BlockedError2
+} from "./event-logger-yzjhj2th.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/plugin/plan.ts
 var exports_plan = {};
 __export(exports_plan, {
   PlanPlugin: () => exports_plan,
-  Plugin: () => Plugin
+  Plugin: () => Plugin9
 });
 import { Message, ToolFailure } from "@opencode-ai/ai";
 import { define } from "@opencode-ai/plugin/effect/plugin";
@@ -29,7 +29,7 @@ You remain in Plan mode until the user switches agents. If the user asks you to
 var leave = `<system-reminder>
 You are NO LONGER in Plan mode. The previous Plan restrictions no longer apply. Any Plan mode instructions from earlier in this conversation are no longer active.
 </system-reminder>`;
-var Plugin = define({
+var Plugin9 = define({
   id: "opencode.plan",
   effect: Effect.fn(function* (ctx) {
     const global = yield* Global.Service;
@@ -53,7 +53,7 @@ var Plugin = define({
         return Effect.void;
       if (event.tool !== "edit" && event.tool !== "write" && event.tool !== "patch")
         return Effect.void;
-      if (!(event.error.error instanceof exports_permission.BlockedError))
+      if (!(event.error.error instanceof BlockedError2))
         return Effect.void;
       event.error = new ToolFailure({
         message: `Cannot use ${event.tool} to modify files outside the Plan directory: ${directory}`
@@ -106,4 +106,4 @@ function lastReminder(messages, enterReminder) {
   }, undefined);
 }
 
-export { Plugin, exports_plan };
+export { Plugin9, exports_plan };

package/dist/chunks/{schema-vac9eqd2.js → event-logger-j5zkgpj8.js}

@@ -7,7 +7,7 @@ function isFileId(data, prefixes) {
     return false;
   return prefixes.some((prefix) => data.startsWith(prefix));
 }
-async function convertToOpenAIResponsesInput({
+async function convertToOpenAIResponsesInput2({
   prompt,
   systemMessageMode,
   fileIdPrefixes,
@@ -223,4 +223,4 @@ var openaiResponsesReasoningProviderOptionsSchema = z.object({
   reasoningEncryptedContent: z.string().nullish()
 });
 
-export { convertToOpenAIResponsesInput };
+export { convertToOpenAIResponsesInput2 };

package/dist/chunks/{schema-kxb4nqfb.js → event-logger-j6q9fy2f.js}

@@ -1,12 +1,12 @@
 import {
-  EffectSQLiteSession
-} from "./schema-8e4szv2f.js";
+  jitCompatCheck2
+} from "./event-logger-emrn6kk6.js";
 import {
-  SQLiteEffectDatabase
-} from "./schema-syzvtymk.js";
+  SQLiteEffectDatabase2
+} from "./event-logger-3xfkzkzd.js";
 import {
-  jitCompatCheck
-} from "./schema-k8b45nas.js";
+  EffectSQLiteSession2
+} from "./event-logger-tksywzaq.js";
 
 // src/database/drizzle/effect-sqlite/driver.ts
 import * as Effect from "effect/Effect";
@@ -16,27 +16,27 @@ import { EffectCache } from "drizzle-orm/cache/core/cache-effect";
 import { EffectLogger } from "drizzle-orm/effect-core";
 import { entityKind } from "drizzle-orm/entity";
 import { SQLiteDialect } from "drizzle-orm/sqlite-core/dialect";
-class EffectSQLiteDatabase extends SQLiteEffectDatabase {
+class EffectSQLiteDatabase2 extends SQLiteEffectDatabase2 {
   static [entityKind] = "EffectSQLiteDatabase";
 }
-var DefaultServices = Layer.merge(EffectCache.Default, EffectLogger.Default);
-var make = Effect.fn("SQLiteDrizzle.make")(function* (config = {}) {
+var DefaultServices2 = Layer.merge(EffectCache.Default, EffectLogger.Default);
+var make21 = Effect.fn("SQLiteDrizzle.make")(function* (config = {}) {
   const client = yield* SqlClient;
   const cache = yield* EffectCache;
   const logger = yield* EffectLogger;
-  const useJitMappers = jitCompatCheck(config.jit);
+  const useJitMappers = jitCompatCheck2(config.jit);
   const dialect = new SQLiteDialect({ useJitMappers });
   const relations = config.relations ?? {};
-  const session = new EffectSQLiteSession(client, dialect, relations, {
+  const session = new EffectSQLiteSession2(client, dialect, relations, {
     logger,
     cache,
     useJitMappers
   });
-  const db = new EffectSQLiteDatabase(dialect, session, relations);
+  const db = new EffectSQLiteDatabase2(dialect, session, relations);
   db.$client = client;
   db.$cache.invalidate = cache.onMutate;
   return db;
 });
-var makeWithDefaults = (config = {}) => make(config).pipe(Effect.provide(DefaultServices));
+var makeWithDefaults2 = (config = {}) => make21(config).pipe(Effect.provide(DefaultServices2));
 
-export { EffectSQLiteDatabase, DefaultServices, make, makeWithDefaults };
+export { EffectSQLiteDatabase2, DefaultServices2, make21, makeWithDefaults2 };

package/dist/chunks/{schema-x3vb5b1t.js → event-logger-j83byb14.js}

@@ -1,15 +1,15 @@
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/v1/config/skills.ts
 var exports_skills = {};
 __export(exports_skills, {
   ConfigSkillsV1: () => exports_skills,
-  Info: () => Info
+  Info: () => Info12
 });
 import { Schema } from "effect";
-var Info = Schema.Struct({
+var Info12 = Schema.Struct({
   paths: Schema.optional(Schema.Array(Schema.String)).annotate({
     description: "Additional paths to skill folders"
   }),
@@ -18,4 +18,4 @@ var Info = Schema.Struct({
   })
 });
 
-export { Info, exports_skills };
+export { Info12, exports_skills };

package/dist/chunks/{schema-8y5vxhk7.js → event-logger-j8nnq7em.js}

@@ -1,18 +1,19 @@
 import {
-  exports_provider
-} from "./schema-68yag814.js";
+  isAISDK2,
+  packageName2
+} from "./event-logger-rwbhhn1p.js";
 
 // src/plugin/provider/zenmux.ts
 import { Effect } from "effect";
 import { define } from "@opencode-ai/plugin/effect/plugin";
-var ZenmuxPlugin = define({
+var ZenmuxPlugin2 = define({
   id: "opencode.provider.zenmux",
   effect: Effect.fn(function* (ctx) {
     yield* ctx.catalog.transform((evt) => {
       for (const item of evt.provider.list()) {
-        if (!exports_provider.isAISDK(item.provider.package))
+        if (!isAISDK2(item.provider.package))
           continue;
-        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/openai-compatible")
+        if (packageName2(item.provider.package) !== "@ai-sdk/openai-compatible")
           continue;
         if (item.provider.settings?.baseURL !== "https://zenmux.ai/api/v1")
           continue;
@@ -28,4 +29,4 @@ var ZenmuxPlugin = define({
   })
 });
 
-export { ZenmuxPlugin };
+export { ZenmuxPlugin2 };

package/dist/chunks/{schema-dkmkay92.js → event-logger-j935v87r.js}

@@ -1,9 +1,9 @@
 // src/filesystem/watcher-binding.ts
 import { createRequire } from "node:module";
-function load() {
+function load3() {
   const require2 = createRequire(import.meta.url);
   const libc = typeof OPENCODE_LIBC === "undefined" ? undefined : OPENCODE_LIBC;
   return require2(process.env.OPENCODE_PARCEL_WATCHER_PATH ?? `@parcel/watcher-${process.platform}-${process.arch}${process.platform === "linux" ? `-${libc || "glibc"}` : ""}`);
 }
 
-export { load };
+export { load3 };

package/dist/chunks/{schema-qz5gwjr7.js → event-logger-jasnfvjs.js}

@@ -1,25 +1,25 @@
 import {
-  AbsolutePath,
-  RelativePath
-} from "./schema-j07kk359.js";
+  AbsolutePath2,
+  RelativePath2
+} from "./event-logger-p8qxwesx.js";
 import {
-  exports_keyed_mutex
-} from "./schema-66mds5ht.js";
+  makeUnsafe2
+} from "./event-logger-y71avatq.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/git.ts
-var exports_git = {};
-__export(exports_git, {
-  Git: () => exports_git,
-  OperationError: () => OperationError,
-  Repository: () => Repository,
-  Service: () => Service,
-  TreeID: () => TreeID,
-  Worktree: () => Worktree,
-  WorktreeError: () => WorktreeError,
-  node: () => node
+var exports_git3 = {};
+__export(exports_git3, {
+  Git: () => exports_git3,
+  OperationError: () => OperationError3,
+  Repository: () => Repository2,
+  Service: () => Service77,
+  TreeID: () => TreeID2,
+  Worktree: () => Worktree2,
+  WorktreeError: () => WorktreeError2,
+  node: () => node82
 });
 import path from "path";
 import { Context, Effect, Layer, Schema } from "effect";
@@ -27,10 +27,10 @@ import { ChildProcess } from "effect/unstable/process";
 import { FSUtil } from "@opencode-ai/util/fs-util";
 import { AppProcess } from "@opencode-ai/util/process";
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
-class Repository extends Schema.Class("Git.Repository")({
-  worktree: AbsolutePath,
-  gitDirectory: AbsolutePath,
-  commonDirectory: AbsolutePath
+class Repository2 extends Schema.Class("Git.Repository")({
+  worktree: AbsolutePath2,
+  gitDirectory: AbsolutePath2,
+  commonDirectory: AbsolutePath2
 }) {
 }
 var snapshotConfigFile = "opencode.gitconfig";
@@ -49,9 +49,9 @@ var snapshotConfig = `[core]
 	version = 4
 	threads = true
 `;
-var TreeID = Schema.String.pipe(Schema.brand("Git.TreeID"));
+var TreeID2 = Schema.String.pipe(Schema.brand("Git.TreeID"));
 
-class OperationError extends Schema.TaggedError()("Git.OperationError", {
+class OperationError3 extends Schema.TaggedError()("Git.OperationError", {
   operation: Schema.Literals([
     "clone",
     "fetch",
@@ -65,32 +65,32 @@ class OperationError extends Schema.TaggedError()("Git.OperationError", {
     "restore"
   ]),
   message: Schema.String,
-  directory: Schema.optional(AbsolutePath),
+  directory: Schema.optional(AbsolutePath2),
   cause: Schema.optional(Schema.Defect())
 }) {
 }
 
-class Worktree extends Schema.Class("Git.Worktree")({
-  directory: AbsolutePath,
+class Worktree2 extends Schema.Class("Git.Worktree")({
+  directory: AbsolutePath2,
   kind: Schema.Literals(["main", "linked"])
 }) {
 }
 
-class WorktreeError extends Schema.TaggedError()("Git.WorktreeError", {
+class WorktreeError2 extends Schema.TaggedError()("Git.WorktreeError", {
   operation: Schema.Literals(["create", "remove", "list"]),
   message: Schema.String,
-  directory: Schema.optional(AbsolutePath),
+  directory: Schema.optional(AbsolutePath2),
   forceRequired: Schema.optional(Schema.Boolean),
   cause: Schema.optional(Schema.Defect())
 }) {
 }
 
-class Service extends Context.Service()("@opencode/Git") {
+class Service77 extends Context.Service()("@opencode/Git") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service77, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
   const proc = yield* AppProcess.Service;
-  const locks = exports_keyed_mutex.makeUnsafe();
+  const locks = makeUnsafe2();
   const locked = (repository, effect) => locks.withLock(repository.gitDirectory)(effect);
   const discover = Effect.fn("Git.repo.discover")(function* (input) {
     const dotgit = yield* fs.up({ targets: [".git"], start: input, mode: "first" }).pipe(Effect.map((matches) => matches[0]), Effect.orElseSucceed(() => {
@@ -103,10 +103,10 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const [gitDir, commonDir, topLevel] = result.text.split(/\r?\n/);
     if (!gitDir || !commonDir)
       return;
-    return new Repository({
-      worktree: AbsolutePath.make(topLevel ? resolvePath(cwd, topLevel) : cwd),
-      gitDirectory: AbsolutePath.make(resolvePath(cwd, gitDir)),
-      commonDirectory: AbsolutePath.make(resolvePath(cwd, commonDir))
+    return new Repository2({
+      worktree: AbsolutePath2.make(topLevel ? resolvePath(cwd, topLevel) : cwd),
+      gitDirectory: AbsolutePath2.make(resolvePath(cwd, gitDir)),
+      commonDirectory: AbsolutePath2.make(resolvePath(cwd, commonDir))
     });
   });
   const remote = Effect.fn("Git.remote.get")(function* (repository, name = "origin") {
@@ -140,18 +140,18 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       return;
     return result.text.trim().replace(new RegExp(`^refs/remotes/${remoteName}/`), "") || undefined;
   });
-  const operation = Effect.fnUntraced(function* (operation2, directory, args) {
-    const result = yield* execute(directory, proc, args).pipe(Effect.mapError((cause) => new OperationError({ operation: operation2, directory, message: cause.message, cause })));
+  const operation = Effect.fnUntraced(function* (operation, directory, args) {
+    const result = yield* execute(directory, proc, args).pipe(Effect.mapError((cause) => new OperationError3({ operation, directory, message: cause.message, cause })));
     if (result.exitCode === 0)
       return;
-    return yield* new OperationError({
-      operation: operation2,
+    return yield* new OperationError3({
+      operation,
       directory,
-      message: result.stderr.trim() || result.text.trim() || `Git ${operation2} failed`
+      message: result.stderr.trim() || result.text.trim() || `Git ${operation} failed`
     });
   });
   const clone = Effect.fn("Git.repo.clone")(function* (input) {
-    yield* operation("clone", AbsolutePath.make(path.dirname(input.directory)), [
+    yield* operation("clone", AbsolutePath2.make(path.dirname(input.directory)), [
       "clone",
       "--depth",
       String(input.depth ?? 100),
@@ -163,7 +163,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const repository = yield* discover(input.directory);
     if (repository)
       return repository;
-    return yield* new OperationError({
+    return yield* new OperationError3({
       operation: "clone",
       directory: input.directory,
       message: "Cloned repository could not be opened"
@@ -199,7 +199,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       cwd: repository.worktree,
       env: options?.env,
       extendEnv: true
-    }), { stdin: options?.stdin }).pipe(Effect.mapError((cause) => new OperationError({
+    }), { stdin: options?.stdin }).pipe(Effect.mapError((cause) => new OperationError3({
       operation: operationName,
       directory: repository.worktree,
       message: cause.message,
@@ -208,16 +208,16 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const text = result.stdout.toString("utf8");
     if (result.exitCode === 0)
       return { text, stderr: result.stderr.toString("utf8") };
-    return yield* new OperationError({
+    return yield* new OperationError3({
       operation: operationName,
       directory: repository.worktree,
       message: result.stderr.toString("utf8").trim() || text.trim() || `Git ${operationName} failed`
     });
   });
   const create = Effect.fn("Git.repo.create")(function* (input) {
-    const operationError = (message) => (cause) => new OperationError({ operation: "create", directory: input.gitDirectory, message, cause });
+    const operationError = (message) => (cause) => new OperationError3({ operation: "create", directory: input.gitDirectory, message, cause });
     yield* fs.ensureDir(input.gitDirectory).pipe(Effect.mapError(operationError("Failed to create Git storage")));
-    const repository = new Repository({
+    const repository = new Repository2({
       worktree: input.worktree,
       gitDirectory: input.gitDirectory,
       commonDirectory: input.gitDirectory
@@ -251,13 +251,13 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       list(["diff-files", "--name-only", "-z", "--", input.scope]),
       list(["ls-files", "--others", "--exclude-standard", "-z", "--", input.scope])
     ], { concurrency: 2 });
-    const candidates = Array.from(new Set([...tracked, ...untracked])).map((file) => RelativePath.make(file));
+    const candidates = Array.from(new Set([...tracked, ...untracked])).map((file) => RelativePath2.make(file));
     if (!candidates.length)
       return { skipped: [] };
     const excluded = input.ignores ? yield* ignored({ repository: input.ignores, paths: candidates }) : new Set;
     const allowed = candidates.filter((item) => !excluded.has(item));
     const maximum = input.maximumUntrackedFileBytes;
-    const skipped = maximum ? (yield* Effect.forEach(untracked.filter((item) => allowed.includes(RelativePath.make(item))), (item) => fs.stat(path.join(input.repository.worktree, item)).pipe(Effect.map((info) => info.type === "File" && Number(info.size) > maximum ? RelativePath.make(item) : undefined), Effect.orElseSucceed(() => {
+    const skipped = maximum ? (yield* Effect.forEach(untracked.filter((item) => allowed.includes(RelativePath2.make(item))), (item) => fs.stat(path.join(input.repository.worktree, item)).pipe(Effect.map((info) => info.type === "File" && Number(info.size) > maximum ? RelativePath2.make(item) : undefined), Effect.orElseSucceed(() => {
       return;
     })), { concurrency: 8 })).filter((item) => item !== undefined) : [];
     const stage = allowed.filter((item) => !skipped.includes(item));
@@ -274,22 +274,22 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const result = yield* proc.run(ChildProcess.make("git", repositoryArgs(input.repository, ["check-ignore", "--no-index", "--stdin", "-z"]), {
       cwd: input.repository.worktree,
       extendEnv: true
-    }), { stdin: input.paths.join("\x00") + "\x00" }).pipe(Effect.mapError((cause) => new OperationError({
+    }), { stdin: input.paths.join("\x00") + "\x00" }).pipe(Effect.mapError((cause) => new OperationError3({
       operation: "list_files",
       directory: input.repository.worktree,
       message: cause.message,
       cause
     })));
     if (result.exitCode !== 0 && result.exitCode !== 1)
-      return yield* new OperationError({
+      return yield* new OperationError3({
         operation: "list_files",
         directory: input.repository.worktree,
         message: result.stderr.toString("utf8").trim() || "Failed to check ignored paths"
       });
-    return new Set(result.stdout.toString("utf8").split("\x00").filter(Boolean).map((file) => RelativePath.make(file)));
+    return new Set(result.stdout.toString("utf8").split("\x00").filter(Boolean).map((file) => RelativePath2.make(file)));
   });
   const writeTree = Effect.fn("Git.tree.write")(function* (repository) {
-    return TreeID.make((yield* repositoryOperation("write_tree", repository, ["write-tree"])).text.trim());
+    return TreeID2.make((yield* repositoryOperation("write_tree", repository, ["write-tree"])).text.trim());
   });
   const captureTree = Effect.fn("Git.tree.capture")((input) => locked(input.repository, Effect.gen(function* () {
     yield* Effect.forEach(input.scopes, (scope) => refresh({ ...input, scope }), { discard: true });
@@ -303,7 +303,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       "-z",
       input.from,
       input.to
-    ])).text.split("\x00").filter(Boolean).map((file) => RelativePath.make(file));
+    ])).text.split("\x00").filter(Boolean).map((file) => RelativePath2.make(file));
   });
   const treeDiff = Effect.fn("Git.tree.diff")(function* (input) {
     const paths = input.paths ?? (yield* treeFiles(input));
@@ -357,7 +357,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     if (!text)
       return false;
     if (!/^\d+\s+\w+\s+[0-9a-f]+\t/.test(text))
-      return yield* new OperationError({
+      return yield* new OperationError3({
         operation: "restore",
         directory: repository.worktree,
         message: `Invalid tree entry for ${file}`
@@ -369,23 +369,23 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       yield* repositoryOperation("restore", input.repository, ["checkout", tree, "--", file]);
       return;
     }
-    yield* fs.remove(path.join(input.repository.worktree, file), { recursive: true, force: true }).pipe(Effect.mapError((cause) => new OperationError({
+    yield* fs.remove(path.join(input.repository.worktree, file), { recursive: true, force: true }).pipe(Effect.mapError((cause) => new OperationError3({
       operation: "restore",
       directory: input.repository.worktree,
       message: `Failed to remove ${file}`,
       cause
     })));
   }), { discard: true })));
-  const worktreeRun = Effect.fnUntraced(function* (operation2, repository, args, worktreeDirectory, cwd = repository.worktree) {
-    const result = yield* proc.run(ChildProcess.make("git", args, { cwd, extendEnv: true, stdin: "ignore" })).pipe(Effect.mapError((cause) => new WorktreeError({ operation: operation2, directory: worktreeDirectory, message: cause.message, cause })));
+  const worktreeRun = Effect.fnUntraced(function* (operation, repository, args, worktreeDirectory, cwd = repository.worktree) {
+    const result = yield* proc.run(ChildProcess.make("git", args, { cwd, extendEnv: true, stdin: "ignore" })).pipe(Effect.mapError((cause) => new WorktreeError2({ operation, directory: worktreeDirectory, message: cause.message, cause })));
     if (result.exitCode === 0)
       return result.stdout.toString("utf8");
     const message = result.stderr.toString("utf8").trim() || result.stdout.toString("utf8").trim() || "Git failed";
-    return yield* new WorktreeError({
-      operation: operation2,
+    return yield* new WorktreeError2({
+      operation,
       directory: worktreeDirectory,
       message,
-      forceRequired: operation2 === "remove" && /contains modified or untracked files|is dirty/i.test(message)
+      forceRequired: operation === "remove" && /contains modified or untracked files|is dirty/i.test(message)
     });
   });
   const worktreeCreate = Effect.fn("Git.worktree.create")(function* (input) {
@@ -393,7 +393,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const repository = yield* discover(input.directory);
     if (repository)
       return repository;
-    return yield* new WorktreeError({
+    return yield* new WorktreeError2({
       operation: "create",
       directory: input.directory,
       message: "Created worktree could not be opened"
@@ -404,12 +404,12 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   });
   const worktreeList = Effect.fn("Git.worktree.list")(function* (repository) {
     return (yield* worktreeRun("list", repository, ["worktree", "list", "--porcelain"])).split(`
-`).filter((line) => line.startsWith("worktree ")).map((line, index) => new Worktree({
-      directory: AbsolutePath.make(resolvePath(repository.worktree, line.slice("worktree ".length).trim())),
+`).filter((line) => line.startsWith("worktree ")).map((line, index) => new Worktree2({
+      directory: AbsolutePath2.make(resolvePath(repository.worktree, line.slice("worktree ".length).trim())),
       kind: index === 0 ? "main" : "linked"
     }));
   });
-  return Service.of({
+  return Service77.of({
     repo: { discover, clone, create },
     remote: { get: remote },
     history: { head, branch, defaultRemoteBranch: remoteHead, rootCommits: roots },
@@ -425,7 +425,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     }
   });
 }));
-var node = makeGlobalNode({ service: Service, layer, deps: [FSUtil.node, AppProcess.node] });
+var node82 = makeGlobalNode({ service: Service77, layer, deps: [FSUtil.node, AppProcess.node] });
 function run(cwd, proc, args) {
   return execute(cwd, proc, args).pipe(Effect.orElseSucceed(() => ({ exitCode: 1, text: "", stderr: "" })));
 }
@@ -450,4 +450,4 @@ function resolvePath(cwd, value) {
   return path.resolve(cwd, normalized);
 }
 
-export { Repository, TreeID, OperationError, Worktree, WorktreeError, Service, node, exports_git };
+export { Repository2, TreeID2, OperationError3, Worktree2, WorktreeError2, Service77, node82, exports_git3 };