@opencode-ai/core 0.0.0-next-17403 → 0.0.0-next-17430

package/dist/chunks/{file-r181tj8c.js → location-mutation-5nh5hezc.js}

@@ -1,24 +1,24 @@
 import {
   fileDiff
-} from "./file-c77ad0vh.js";
-import {
-  exports_location_mutation
-} from "./file-je3y3jh3.js";
+} from "./location-mutation-c77ad0vh.js";
 import {
   exports_formatter
-} from "./file-5wm2dksb.js";
+} from "./location-mutation-g6tw2wts.js";
 import {
   exports_file_mutation
-} from "./file-dsax7ex2.js";
+} from "./location-mutation-qcrc8pqp.js";
 import {
-  exports_environment1 as exports_environment
-} from "./file-spj6bbpr.js";
+  exports_location_mutation
+} from "./location-mutation-3b1fswre.js";
 import {
   exports_permission
-} from "./file-dg389w8c.js";
+} from "./location-mutation-mqjfxy6k.js";
+import {
+  exports_environment1 as exports_environment
+} from "./location-mutation-r5fy7jaj.js";
 import {
   __export
-} from "./file-rvfvac9x.js";
+} from "./location-mutation-rvfvac9x.js";
 
 // src/tool/plugin/write.ts
 var exports_write = {};

package/dist/chunks/{file-5p2sx24b.js → location-mutation-5p2sx24b.js}

@@ -1,12 +1,12 @@
 import {
   exports_model
-} from "./file-xfd1xnk3.js";
+} from "./location-mutation-xfd1xnk3.js";
 import {
   exports_provider
-} from "./file-d6vvk673.js";
+} from "./location-mutation-d6vvk673.js";
 import {
   __export
-} from "./file-rvfvac9x.js";
+} from "./location-mutation-rvfvac9x.js";
 
 // src/plugin/variant.ts
 var exports_variant = {};

package/dist/chunks/{file-5pfeh60c.js → location-mutation-5pfeh60c.js}

@@ -2,10 +2,10 @@ import {
   Failed,
   NotFound,
   WrongKind
-} from "./file-zthe9zqc.js";
+} from "./location-mutation-zthe9zqc.js";
 import {
   __export
-} from "./file-rvfvac9x.js";
+} from "./location-mutation-rvfvac9x.js";
 
 // src/environment/exec-defaults.ts
 var exports_exec_defaults = {};

package/dist/chunks/{file-5rs65q6p.js → location-mutation-5rs65q6p.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./file-rvfvac9x.js";
+} from "./location-mutation-rvfvac9x.js";
 
 // src/database/sqlite.ts
 var exports_sqlite = {};

package/dist/chunks/{file-5sgbvx3z.js → location-mutation-5sgbvx3z.js}

@@ -2,10 +2,10 @@ import {
   Failed,
   NotFound,
   WrongKind
-} from "./file-zthe9zqc.js";
+} from "./location-mutation-zthe9zqc.js";
 import {
   __export
-} from "./file-rvfvac9x.js";
+} from "./location-mutation-rvfvac9x.js";
 
 // src/environment/local.ts
 var exports_local = {};

package/dist/chunks/location-mutation-61kbpxak.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-a1rjphzg.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_bus
+} from "./location-mutation-n8nwk0yn.js";
+import {
+  exports_database
+} from "./location-mutation-7jcjw3aq.js";
+import {
+  exports_git
+} from "./location-mutation-kcwh27nh.js";
+import {
+  AbsolutePath
+} from "./location-mutation-j07kk359.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/{file-q50btfg8.js → location-mutation-64jjq47w.js}

@@ -1,36 +1,36 @@
-import {
-  exports_oauth
-} from "./file-xq1vkeee.js";
 import {
   exports_client
-} from "./file-epr59vh3.js";
+} from "./location-mutation-125t8n5e.js";
+import {
+  exports_oauth
+} from "./location-mutation-xq1vkeee.js";
 import {
   exports_integration
-} from "./file-xq5g3gjg.js";
+} from "./location-mutation-byapkyxa.js";
 import {
   exports_form
-} from "./file-89xgxbta.js";
+} from "./location-mutation-xh32hk89.js";
 import {
   exports_environment1 as exports_environment
-} from "./file-spj6bbpr.js";
+} from "./location-mutation-r5fy7jaj.js";
 import {
   exports_config
-} from "./file-hqcvr4pq.js";
+} from "./location-mutation-a5wmgav8.js";
 import {
   exports_credential
-} from "./file-j2z43mps.js";
+} from "./location-mutation-hcewn7yc.js";
 import {
   exports_location
-} from "./file-wcn5x42d.js";
+} from "./location-mutation-a1rjphzg.js";
 import {
   exports_bus
-} from "./file-knch8gq3.js";
+} from "./location-mutation-n8nwk0yn.js";
 import {
   exports_keyed_mutex
-} from "./file-0kvmztkf.js";
+} from "./location-mutation-0kvmztkf.js";
 import {
   __export
-} from "./file-rvfvac9x.js";
+} from "./location-mutation-rvfvac9x.js";
 
 // src/mcp/index.ts
 var exports_mcp = {};

package/dist/chunks/{file-m1kg34f8.js → location-mutation-68x2vr81.js}

@@ -1,54 +1,54 @@
 import {
   exports_host
-} from "./file-n7fc11e4.js";
+} from "./location-mutation-ys5ebwvd.js";
 import {
   exports_runtime
-} from "./file-9qhx1q0s.js";
+} from "./location-mutation-1xqbk91z.js";
 import {
-  exports_catalog
-} from "./file-zvvqrm9j.js";
-import {
-  exports_websearch
-} from "./file-8nwtst08.js";
+  exports_skill
+} from "./location-mutation-3g101c70.js";
 import {
   exports_tool
-} from "./file-qpxjj5fe.js";
-import {
-  exports_app
-} from "./file-50jxp3hw.js";
+} from "./location-mutation-34tb0anc.js";
 import {
   exports_hooks
-} from "./file-t2j2ttmx.js";
+} from "./location-mutation-t2j2ttmx.js";
 import {
   exports_command
-} from "./file-f9c6f2tj.js";
+} from "./location-mutation-kb4hzjkb.js";
 import {
-  exports_integration
-} from "./file-xq5g3gjg.js";
-import {
-  exports_aisdk
-} from "./file-d076mabj.js";
-import {
-  exports_skill
-} from "./file-x7r4ry9d.js";
+  exports_catalog
+} from "./location-mutation-m1a1hezg.js";
 import {
   exports_agent
-} from "./file-as13d7jp.js";
+} from "./location-mutation-cnjn67jn.js";
 import {
-  exports_location
-} from "./file-wcn5x42d.js";
+  exports_aisdk
+} from "./location-mutation-d076mabj.js";
+import {
+  exports_websearch
+} from "./location-mutation-h90cytwx.js";
 import {
   exports_reference
-} from "./file-my4a0tz0.js";
+} from "./location-mutation-d6jrwgq9.js";
+import {
+  exports_integration
+} from "./location-mutation-byapkyxa.js";
 import {
   exports_state
-} from "./file-wt193r4g.js";
+} from "./location-mutation-wt193r4g.js";
+import {
+  exports_app
+} from "./location-mutation-50jxp3hw.js";
+import {
+  exports_location
+} from "./location-mutation-a1rjphzg.js";
 import {
   exports_bus
-} from "./file-knch8gq3.js";
+} from "./location-mutation-n8nwk0yn.js";
 import {
   __export
-} from "./file-rvfvac9x.js";
+} from "./location-mutation-rvfvac9x.js";
 
 // src/plugin.ts
 var exports_plugin = {};

package/dist/chunks/{file-ajdmexs0.js → location-mutation-6gnb35n6.js}

@@ -1,96 +1,96 @@
 import {
-  CloudflareAIGatewayPlugin
-} from "./file-b0gc5gc4.js";
+  ZenmuxPlugin
+} from "./location-mutation-56p2m126.js";
 import {
-  KiloPlugin
-} from "./file-cgvnqv92.js";
+  VercelPlugin
+} from "./location-mutation-9r0qzhnf.js";
 import {
-  OpenRouterPlugin
-} from "./file-3vh42rcr.js";
+  CloudflareWorkersAIPlugin
+} from "./location-mutation-yh2ps9fk.js";
 import {
   NvidiaPlugin
-} from "./file-fm1nvm5g.js";
+} from "./location-mutation-fm1nvm5g.js";
 import {
-  VercelPlugin
-} from "./file-9r0qzhnf.js";
+  OpenRouterPlugin
+} from "./location-mutation-3vh42rcr.js";
 import {
-  GitLabPlugin
-} from "./file-3w0f1yxt.js";
+  SapAICorePlugin
+} from "./location-mutation-857g7h76.js";
 import {
-  CerebrasPlugin
-} from "./file-10xtr3be.js";
+  LLMGatewayPlugin
+} from "./location-mutation-04t2zee8.js";
 import {
-  ZenmuxPlugin
-} from "./file-56p2m126.js";
+  GatewayPlugin
+} from "./location-mutation-smpeg8c9.js";
 import {
-  SapAICorePlugin
-} from "./file-857g7h76.js";
+  MistralPlugin
+} from "./location-mutation-3thh6229.js";
 import {
-  TogetherAIPlugin
-} from "./file-jssy2dr3.js";
+  VenicePlugin
+} from "./location-mutation-xwftk1fd.js";
+import {
+  AmazonBedrockPlugin
+} from "./location-mutation-rqswsgbs.js";
+import {
+  SnowflakeCortexPlugin
+} from "./location-mutation-we2zmhe4.js";
 import {
   GithubCopilotPlugin
-} from "./file-f498y0cd.js";
+} from "./location-mutation-qs8s5cph.js";
+import {
+  PerplexityPlugin
+} from "./location-mutation-wps8gh8n.js";
+import {
+  OpenAIPlugin
+} from "./location-mutation-vbef7eh6.js";
 import {
   AnthropicPlugin
-} from "./file-ddn74qps.js";
+} from "./location-mutation-ddn74qps.js";
 import {
   GoogleVertexPlugin
-} from "./file-ts4t4v20.js";
+} from "./location-mutation-ts4t4v20.js";
 import {
-  OpenAICompatiblePlugin
-} from "./file-fmyre8m1.js";
+  AlibabaPlugin
+} from "./location-mutation-4zzdwbaz.js";
 import {
-  DeepInfraPlugin
-} from "./file-pfqehjmy.js";
+  AzurePlugin
+} from "./location-mutation-4vtx7cev.js";
 import {
-  AlibabaPlugin
-} from "./file-4zzdwbaz.js";
+  GitLabPlugin
+} from "./location-mutation-3w0f1yxt.js";
 import {
-  VenicePlugin
-} from "./file-xwftk1fd.js";
+  OpenAICompatiblePlugin
+} from "./location-mutation-fmyre8m1.js";
 import {
-  GatewayPlugin
-} from "./file-smpeg8c9.js";
+  TogetherAIPlugin
+} from "./location-mutation-jssy2dr3.js";
 import {
-  DynamicProviderPlugin
-} from "./file-3q6gbwmd.js";
+  DeepInfraPlugin
+} from "./location-mutation-pfqehjmy.js";
 import {
-  PerplexityPlugin
-} from "./file-wps8gh8n.js";
+  XAIPlugin
+} from "./location-mutation-xs439e4m.js";
 import {
-  OpencodePlugin
-} from "./file-sb0z03rs.js";
+  CerebrasPlugin
+} from "./location-mutation-10xtr3be.js";
 import {
   CoherePlugin
-} from "./file-qe0d689s.js";
+} from "./location-mutation-qe0d689s.js";
 import {
-  LLMGatewayPlugin
-} from "./file-5h7b67x4.js";
+  KiloPlugin
+} from "./location-mutation-cgvnqv92.js";
 import {
   GroqPlugin
-} from "./file-ayfwnm78.js";
+} from "./location-mutation-ayfwnm78.js";
 import {
-  CloudflareWorkersAIPlugin
-} from "./file-pea3nhwj.js";
-import {
-  OpenAIPlugin
-} from "./file-c9jmxy9r.js";
-import {
-  MistralPlugin
-} from "./file-3thh6229.js";
-import {
-  AmazonBedrockPlugin
-} from "./file-rqswsgbs.js";
-import {
-  SnowflakeCortexPlugin
-} from "./file-we2zmhe4.js";
+  OpencodePlugin
+} from "./location-mutation-59bcz2pr.js";
 import {
-  XAIPlugin
-} from "./file-zkw93360.js";
+  DynamicProviderPlugin
+} from "./location-mutation-3q6gbwmd.js";
 import {
-  AzurePlugin
-} from "./file-04fhvk4h.js";
+  CloudflareAIGatewayPlugin
+} from "./location-mutation-wf2b4nse.js";
 
 // src/plugin/provider.ts
 var ProviderPlugins = [