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

package/dist/chunks/{schema-qbpdt1wp.js → pty-7k8mdtae.js}

@@ -1,15 +1,20 @@
 import {
-  exports_integration
-} from "./schema-b9bp1awf.js";
+  Service79
+} from "./pty-y974v3mv.js";
 import {
-  exports_provider
-} from "./schema-68yag814.js";
+  OAuth3,
+  Event16
+} from "./pty-bzq1f2yq.js";
 import {
-  exports_credential
-} from "./schema-jgzett5g.js";
+  ID5,
+  MethodID2
+} from "./pty-pk02mbyy.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  ID18,
+  aisdk2,
+  mergeOverlay2,
+  mergeHeaders2
+} from "./pty-tdt6s1r3.js";
 
 // src/plugin/provider/opencode.ts
 import { Duration, Effect, Schema, Semaphore, Stream } from "effect";
@@ -19,7 +24,7 @@ import { ConfigProvider } from "@opencode-ai/schema/config/provider";
 import { Money } from "@opencode-ai/schema/money";
 var defaultServer = "https://opencode.ai/console";
 var clientID = "opencode-cli";
-var methodID = exports_integration.MethodID.make("device");
+var methodID = MethodID2.make("device");
 var RemoteResponse = Schema.Struct({ providers: Schema.Record(Schema.String, ConfigProvider.Info) });
 var Device = Schema.Struct({
   device_code: Schema.String,
@@ -39,7 +44,7 @@ var User = Schema.Struct({ id: Schema.String, email: Schema.String });
 var Org = Schema.Struct({ id: Schema.String, name: Schema.String });
 function oauth(http) {
   return {
-    integrationID: exports_integration.ID.make("opencode"),
+    integrationID: ID5.make("opencode"),
     method: {
       id: methodID,
       type: "oauth",
@@ -77,10 +82,10 @@ function oauth(http) {
     label: (credential) => typeof credential.metadata?.orgName === "string" ? credential.metadata.orgName : undefined
   };
 }
-var OpencodePlugin = define({
+var OpencodePlugin2 = define({
   id: "opencode.provider.opencode",
   effect: Effect.fn(function* (ctx) {
-    const bus = yield* exports_bus.Service;
+    const bus = yield* Service79;
     const http = yield* HttpClient.HttpClient;
     const loading = Semaphore.makeUnsafe(1);
     let connected = false;
@@ -102,22 +107,22 @@ var OpencodePlugin = define({
     });
     yield* load();
     yield* ctx.catalog.transform((catalog) => {
-      for (const [providerID, item2] of Object.entries(providers ?? {})) {
-        const source = catalog.provider.get(item2.canonical ?? providerID);
+      for (const [providerID, item] of Object.entries(providers ?? {})) {
+        const source = catalog.provider.get(item.canonical ?? providerID);
         catalog.provider.update(providerID, (provider) => {
           if (source && source.provider !== provider)
             Object.assign(provider, structuredClone(source.provider), { id: provider.id });
-          provider.integrationID = exports_integration.ID.make("opencode");
-          if (item2.canonical !== undefined)
-            provider.canonical = item2.canonical;
-          if (item2.name !== undefined)
-            provider.name = item2.name;
-          provider.package = item2.package ?? provider.package;
-          provider.settings = exports_provider.mergeOverlay(withoutCredentials(provider.settings), withoutCredentials(item2.settings));
-          provider.headers = exports_provider.mergeHeaders(provider.headers, item2.headers);
-          provider.body = exports_provider.mergeOverlay(provider.body, item2.body);
+          provider.integrationID = ID5.make("opencode");
+          if (item.canonical !== undefined)
+            provider.canonical = item.canonical;
+          if (item.name !== undefined)
+            provider.name = item.name;
+          provider.package = item.package ?? provider.package;
+          provider.settings = mergeOverlay2(withoutCredentials(provider.settings), withoutCredentials(item.settings));
+          provider.headers = mergeHeaders2(provider.headers, item.headers);
+          provider.body = mergeOverlay2(provider.body, item.body);
         });
-        for (const [modelID, config] of Object.entries(item2.models ?? {})) {
+        for (const [modelID, config] of Object.entries(item.models ?? {})) {
           const base = source?.models.get(config.modelID ?? modelID) ?? source?.models.get(modelID);
           catalog.model.update(providerID, modelID, (model) => {
             Object.assign(model, structuredClone(base ?? model));
@@ -129,8 +134,8 @@ var OpencodePlugin = define({
               model.modelID = config.modelID;
             if (config.compatibility !== undefined)
               model.compatibility = { ...model.compatibility, ...config.compatibility };
-            model.package = config.package ?? (item2.package !== undefined ? undefined : model.package);
-            if (item2.settings?.baseURL !== undefined && model.settings)
+            model.package = config.package ?? (item.package !== undefined ? undefined : model.package);
+            if (item.settings?.baseURL !== undefined && model.settings)
               delete model.settings.baseURL;
             if (config.capabilities !== undefined)
               model.capabilities = {
@@ -138,21 +143,21 @@ var OpencodePlugin = define({
                 input: [...config.capabilities.input],
                 output: [...config.capabilities.output]
               };
-            model.settings = exports_provider.mergeOverlay(withoutCredentials(model.settings), withoutCredentials(config.settings));
-            model.headers = exports_provider.mergeHeaders(model.headers, config.headers);
-            model.body = exports_provider.mergeOverlay(model.body, config.body);
+            model.settings = mergeOverlay2(withoutCredentials(model.settings), withoutCredentials(config.settings));
+            model.headers = mergeHeaders2(model.headers, config.headers);
+            model.body = mergeOverlay2(model.body, config.body);
             for (const variant of config.variants ?? []) {
-              let existing = model.variants.find((item3) => item3.id === variant.id);
+              let existing = model.variants.find((item) => item.id === variant.id);
               if (!existing) {
                 existing = { id: variant.id };
                 model.variants.push(existing);
               }
               if (variant.settings !== undefined)
-                existing.settings = exports_provider.mergeOverlay(existing.settings, withoutCredentials(variant.settings));
+                existing.settings = mergeOverlay2(existing.settings, withoutCredentials(variant.settings));
               if (variant.headers !== undefined)
-                existing.headers = exports_provider.mergeHeaders(existing.headers, variant.headers);
+                existing.headers = mergeHeaders2(existing.headers, variant.headers);
               if (variant.body !== undefined)
-                existing.body = exports_provider.mergeOverlay(existing.body, variantBody(variant.body, model.package ?? item2.package ?? source?.provider.package));
+                existing.body = mergeOverlay2(existing.body, variantBody(variant.body, model.package ?? item.package ?? source?.provider.package));
             }
             if (config.cost !== undefined)
               model.cost = (Array.isArray(config.cost) ? config.cost : [config.cost]).map((cost) => ({
@@ -170,7 +175,7 @@ var OpencodePlugin = define({
           });
         }
       }
-      const item = catalog.provider.get(exports_provider.ID.opencode);
+      const item = catalog.provider.get(ID18.opencode);
       if (!item)
         return;
       const hasKey = Boolean(process.env.OPENCODE_API_KEY || connected || item.provider.settings?.apiKey);
@@ -191,7 +196,7 @@ var OpencodePlugin = define({
       }
     });
     const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
-    yield* bus.subscribe(exports_credential.Event.Switched).pipe(Stream.filter((event) => event.data.integrationID === exports_integration.ID.make("opencode")), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
+    yield* bus.subscribe(Event16.Switched).pipe(Stream.filter((event) => event.data.integrationID === ID5.make("opencode")), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
   })
 });
 function fetchProviders(http, value) {
@@ -206,7 +211,7 @@ function fetchProviders(http, value) {
   }));
 }
 function variantBody(body, packageName) {
-  if (packageName !== exports_provider.aisdk("@ai-sdk/openai"))
+  if (packageName !== aisdk2("@ai-sdk/openai"))
     return body;
   const { reasoningEffort, reasoningSummary, ...native } = body;
   const reasoning = {
@@ -215,7 +220,7 @@ function variantBody(body, packageName) {
   };
   if (Object.keys(reasoning).length === 0)
     return body;
-  return exports_provider.mergeOverlay({ reasoning }, native);
+  return mergeOverlay2({ reasoning }, native);
 }
 function withoutCredentials(body) {
   return body && Object.fromEntries(Object.entries(body).filter(([key]) => !["apiKey", "authToken", "accessToken"].includes(key)));
@@ -259,7 +264,7 @@ function credential(http, server, token) {
       get(http, `${server}/api/orgs`, token.access_token, Schema.Array(Org))
     ], { concurrency: 2 });
     const org = orgs.toSorted((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id))[0];
-    return exports_credential.OAuth.make({
+    return OAuth3.make({
       type: "oauth",
       methodID,
       access: token.access_token,
@@ -282,4 +287,4 @@ function post(http, url, body, schema, statusOk = true) {
   return HttpClientRequest.post(url).pipe(HttpClientRequest.acceptJson, HttpClientRequest.schemaBodyJson(Schema.Record(Schema.String, Schema.String))(body), Effect.flatMap((request) => http.execute(request)), Effect.flatMap((response) => statusOk ? HttpClientResponse.filterStatusOk(response) : Effect.succeed(response)), Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)));
 }
 
-export { OpencodePlugin };
+export { OpencodePlugin2 };

package/dist/chunks/{schema-0nhdpq2e.js → pty-7n1wp2cn.js}

@@ -1,34 +1,39 @@
 import {
-  exports_repository
-} from "./schema-s32nnj3r.js";
+  AbsolutePath2
+} from "./pty-p8qxwesx.js";
 import {
-  exports_git
-} from "./schema-qz5gwjr7.js";
+  Service77,
+  node82
+} from "./pty-jasnfvjs.js";
 import {
-  exports_kv
-} from "./schema-y2b04s9v.js";
+  parse5,
+  validateBranch3,
+  cachePath2,
+  same2
+} from "./pty-6h73sxmp.js";
 import {
-  AbsolutePath
-} from "./schema-j07kk359.js";
+  Service76,
+  node81
+} from "./pty-xk0vfajd.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/repository-cache.ts
 var exports_repository_cache = {};
 __export(exports_repository_cache, {
-  CacheOperationError: () => CacheOperationError,
-  CheckoutFailedError: () => CheckoutFailedError,
-  CloneFailedError: () => CloneFailedError,
-  FetchFailedError: () => FetchFailedError,
-  InvalidBranchError: () => InvalidBranchError,
-  LockFailedError: () => LockFailedError,
+  CacheOperationError: () => CacheOperationError2,
+  CheckoutFailedError: () => CheckoutFailedError2,
+  CloneFailedError: () => CloneFailedError2,
+  FetchFailedError: () => FetchFailedError2,
+  InvalidBranchError: () => InvalidBranchError2,
+  LockFailedError: () => LockFailedError2,
   RepositoryCache: () => exports_repository_cache,
-  ResetFailedError: () => ResetFailedError,
-  Service: () => Service,
-  isError: () => isError,
-  node: () => node,
-  validateBranch: () => validateBranch
+  ResetFailedError: () => ResetFailedError2,
+  Service: () => Service75,
+  isError: () => isError2,
+  node: () => node80,
+  validateBranch: () => validateBranch2
 });
 import path from "path";
 import { Clock, Context, Duration, Effect, Layer, Option, Schema } from "effect";
@@ -41,82 +46,82 @@ var Refresh = Schema.Struct({
 });
 var refreshInterval = Duration.toMillis(Duration.days(1));
 
-class InvalidBranchError extends Schema.TaggedError()("RepositoryCacheInvalidBranchError", {
+class InvalidBranchError2 extends Schema.TaggedError()("RepositoryCacheInvalidBranchError", {
   branch: Schema.String,
   message: Schema.String
 }) {
 }
 
-class CloneFailedError extends Schema.TaggedError()("RepositoryCacheCloneFailedError", {
+class CloneFailedError2 extends Schema.TaggedError()("RepositoryCacheCloneFailedError", {
   repository: Schema.String,
   message: Schema.String
 }) {
 }
 
-class FetchFailedError extends Schema.TaggedError()("RepositoryCacheFetchFailedError", {
+class FetchFailedError2 extends Schema.TaggedError()("RepositoryCacheFetchFailedError", {
   repository: Schema.String,
   message: Schema.String
 }) {
 }
 
-class CheckoutFailedError extends Schema.TaggedError()("RepositoryCacheCheckoutFailedError", {
+class CheckoutFailedError2 extends Schema.TaggedError()("RepositoryCacheCheckoutFailedError", {
   repository: Schema.String,
   branch: Schema.String,
   message: Schema.String
 }) {
 }
 
-class ResetFailedError extends Schema.TaggedError()("RepositoryCacheResetFailedError", {
+class ResetFailedError2 extends Schema.TaggedError()("RepositoryCacheResetFailedError", {
   repository: Schema.String,
   message: Schema.String
 }) {
 }
 
-class LockFailedError extends Schema.TaggedError()("RepositoryCacheLockFailedError", {
+class LockFailedError2 extends Schema.TaggedError()("RepositoryCacheLockFailedError", {
   localPath: Schema.String,
   message: Schema.String
 }) {
 }
 
-class CacheOperationError extends Schema.TaggedError()("RepositoryCacheOperationError", {
+class CacheOperationError2 extends Schema.TaggedError()("RepositoryCacheOperationError", {
   operation: Schema.String,
   path: Schema.String,
   message: Schema.String
 }) {
 }
 
-class Service extends Context.Service()("@opencode/RepositoryCache") {
+class Service75 extends Context.Service()("@opencode/RepositoryCache") {
 }
-function isError(error) {
-  return error instanceof InvalidBranchError || error instanceof CloneFailedError || error instanceof FetchFailedError || error instanceof CheckoutFailedError || error instanceof ResetFailedError || error instanceof LockFailedError || error instanceof CacheOperationError;
+function isError2(error) {
+  return error instanceof InvalidBranchError2 || error instanceof CloneFailedError2 || error instanceof FetchFailedError2 || error instanceof CheckoutFailedError2 || error instanceof ResetFailedError2 || error instanceof LockFailedError2 || error instanceof CacheOperationError2;
 }
-var validateBranch = Effect.fn("RepositoryCache.validateBranch")(function* (branch) {
+var validateBranch2 = Effect.fn("RepositoryCache.validateBranch")(function* (branch) {
   return yield* Effect.try({
-    try: () => exports_repository.validateBranch(branch),
-    catch: (error) => new InvalidBranchError({ branch, message: errorMessage(error) })
+    try: () => validateBranch3(branch),
+    catch: (error) => new InvalidBranchError2({ branch, message: errorMessage(error) })
   });
 });
-var layer = Layer.effect(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service75, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
-  const git = yield* exports_git.Service;
+  const git = yield* Service77;
   const flock = yield* EffectFlock.Service;
   const global = yield* Global.Service;
-  const kv = yield* exports_kv.Service;
-  return Service.of({
+  const kv = yield* Service76;
+  return Service75.of({
     ensure: Effect.fn("RepositoryCache.ensure")(function* (input) {
       if (input.branch)
-        yield* validateBranch(input.branch);
+        yield* validateBranch2(input.branch);
       const repository = input.reference.label;
-      const localPath = exports_repository.cachePath(global.repos, input.reference, input.branch);
+      const localPath = cachePath2(global.repos, input.reference, input.branch);
       const key = `repository-cache:${localPath}`;
-      const cloneTarget = exports_repository.parse(input.reference.remote) ?? input.reference;
+      const cloneTarget = parse5(input.reference.remote) ?? input.reference;
       return yield* flock.withLock(Effect.gen(function* () {
         yield* cacheOperation(fs.ensureDir(path.dirname(localPath)), "ensure cache directory", localPath);
-        const existing = yield* git.repo.discover(AbsolutePath.make(localPath));
+        const existing = yield* git.repo.discover(AbsolutePath2.make(localPath));
         const origin = existing ? yield* git.remote.get(existing) : undefined;
-        const originReference = origin ? exports_repository.parse(origin) : undefined;
+        const originReference = origin ? parse5(origin) : undefined;
         const worktree = existing ? yield* fs.resolve(localPath) : undefined;
-        const reuse = Boolean(existing && existing.worktree === worktree && originReference && exports_repository.same(originReference, cloneTarget));
+        const reuse = Boolean(existing && existing.worktree === worktree && originReference && same2(originReference, cloneTarget));
         if (!reuse && (yield* fs.existsSafe(localPath))) {
           yield* cacheOperation(fs.remove(localPath, { recursive: true }), "remove stale cache", localPath);
         }
@@ -129,26 +134,26 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           if (status === "cloned") {
             yield* git.repo.clone({
               remote: input.reference.remote,
-              directory: AbsolutePath.make(localPath),
+              directory: AbsolutePath2.make(localPath),
               branch: input.branch
-            }).pipe(Effect.mapError((error) => new CloneFailedError({ repository, message: error.message })));
+            }).pipe(Effect.mapError((error) => new CloneFailedError2({ repository, message: error.message })));
           }
           if (status === "refreshed") {
             if (!existing)
-              return yield* new FetchFailedError({ repository, message: "Repository is unavailable" });
-            yield* git.sync.fetchRemotes(existing).pipe(Effect.mapError((error) => new FetchFailedError({ repository, message: error.message })));
+              return yield* new FetchFailedError2({ repository, message: "Repository is unavailable" });
+            yield* git.sync.fetchRemotes(existing).pipe(Effect.mapError((error) => new FetchFailedError2({ repository, message: error.message })));
             if (input.branch) {
-              yield* git.sync.fetchBranch(existing, { branch: input.branch }).pipe(Effect.mapError((error) => new FetchFailedError({ repository, message: error.message })));
+              yield* git.sync.fetchBranch(existing, { branch: input.branch }).pipe(Effect.mapError((error) => new FetchFailedError2({ repository, message: error.message })));
             }
             const branch = input.branch ?? (yield* git.history.defaultRemoteBranch(existing));
             if (branch) {
-              yield* git.sync.checkoutRemoteBranch(existing, { branch }).pipe(Effect.mapError((error) => new CheckoutFailedError({ repository, branch, message: error.message })));
+              yield* git.sync.checkoutRemoteBranch(existing, { branch }).pipe(Effect.mapError((error) => new CheckoutFailedError2({ repository, branch, message: error.message })));
             }
             const target = branch ?? (yield* git.history.branch(existing));
-            yield* git.sync.resetHard(existing, target ? `origin/${target}` : "HEAD").pipe(Effect.mapError((error) => new ResetFailedError({ repository, message: error.message })));
+            yield* git.sync.resetHard(existing, target ? `origin/${target}` : "HEAD").pipe(Effect.mapError((error) => new ResetFailedError2({ repository, message: error.message })));
           }
         }
-        const checkout = yield* git.repo.discover(AbsolutePath.make(localPath));
+        const checkout = yield* git.repo.discover(AbsolutePath2.make(localPath));
         return {
           repository,
           host: input.reference.host,
@@ -158,20 +163,20 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           head: checkout ? yield* git.history.head(checkout) : undefined,
           branch: checkout ? yield* git.history.branch(checkout) : undefined
         };
-      }), key).pipe(Effect.mapError((error) => isError(error) ? error : new LockFailedError({ localPath, message: errorMessage(error) })));
+      }), key).pipe(Effect.mapError((error) => isError2(error) ? error : new LockFailedError2({ localPath, message: errorMessage(error) })));
     })
   });
 }));
-var node = makeGlobalNode({
-  service: Service,
+var node80 = makeGlobalNode({
+  service: Service75,
   layer,
-  deps: [EffectFlock.node, FSUtil.node, exports_git.node, Global.node, exports_kv.node]
+  deps: [EffectFlock.node, FSUtil.node, node82, Global.node, node81]
 });
 function errorMessage(error) {
   return error instanceof globalThis.Error ? error.message : String(error);
 }
 function cacheOperation(effect, operation, target) {
-  return effect.pipe(Effect.mapError((error) => new CacheOperationError({ operation, path: target, message: errorMessage(error) })));
+  return effect.pipe(Effect.mapError((error) => new CacheOperationError2({ operation, path: target, message: errorMessage(error) })));
 }
 
-export { InvalidBranchError, CloneFailedError, FetchFailedError, CheckoutFailedError, ResetFailedError, LockFailedError, CacheOperationError, Service, isError, validateBranch, node, exports_repository_cache };
+export { InvalidBranchError2, CloneFailedError2, FetchFailedError2, CheckoutFailedError2, ResetFailedError2, LockFailedError2, CacheOperationError2, Service75, isError2, validateBranch2, node80, exports_repository_cache };

package/dist/chunks/{schema-4v6g3p22.js → pty-7w3s9kd0.js}

@@ -1,21 +1,21 @@
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/v1/config/formatter.ts
-var exports_formatter = {};
-__export(exports_formatter, {
-  ConfigFormatterV1: () => exports_formatter,
-  Entry: () => Entry,
-  Info: () => Info
+var exports_formatter3 = {};
+__export(exports_formatter3, {
+  ConfigFormatterV1: () => exports_formatter3,
+  Entry: () => Entry3,
+  Info: () => Info14
 });
 import { Schema } from "effect";
-var Entry = Schema.Struct({
+var Entry3 = Schema.Struct({
   disabled: Schema.optional(Schema.Boolean),
   command: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
   environment: Schema.optional(Schema.Record(Schema.String, Schema.String)),
   extensions: Schema.optional(Schema.mutable(Schema.Array(Schema.String)))
 });
-var Info = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry)]);
+var Info14 = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry3)]);
 
-export { Entry, Info, exports_formatter };
+export { Entry3, Info14, exports_formatter3 };

package/dist/chunks/{schema-qzbgfz7c.js → pty-7zvydh0p.js}

@@ -1,15 +1,17 @@
 import {
-  exports_integration
-} from "./schema-b9bp1awf.js";
+  useragent2
+} from "./pty-vkpagyjs.js";
 import {
-  exports_app
-} from "./schema-hs51b0fc.js";
+  OAuth3,
+  Service68
+} from "./pty-bzq1f2yq.js";
 import {
-  exports_provider
-} from "./schema-68yag814.js";
+  ID5,
+  MethodID2
+} from "./pty-pk02mbyy.js";
 import {
-  exports_credential
-} from "./schema-jgzett5g.js";
+  ID18
+} from "./pty-tdt6s1r3.js";
 
 // src/plugin/provider/xai.ts
 import { define } from "@opencode-ai/plugin/effect/plugin";
@@ -19,9 +21,9 @@ var issuer = "https://auth.x.ai/oauth2";
 var deviceGrant = "urn:ietf:params:oauth:grant-type:device_code";
 var scope = "openid profile email offline_access grok-cli:access api:access";
 var pollingSafetyMargin = 3000;
-var browserMethodID = exports_integration.MethodID.make("browser");
-var deviceMethodID = exports_integration.MethodID.make("device");
-var providerID = exports_provider.ID.make("xai");
+var browserMethodID = MethodID2.make("browser");
+var deviceMethodID = MethodID2.make("device");
+var providerID = ID18.make("xai");
 var Token = Schema.Struct({
   access_token: Schema.String,
   refresh_token: Schema.optional(Schema.String),
@@ -41,7 +43,7 @@ var DeviceError = Schema.Struct({
 });
 var decodeDeviceError = Schema.decodeUnknownOption(Schema.fromJsonString(DeviceError));
 var device = (app) => ({
-  integrationID: exports_integration.ID.make("xai"),
+  integrationID: ID5.make("xai"),
   method: {
     id: deviceMethodID,
     type: "oauth",
@@ -61,17 +63,17 @@ var device = (app) => ({
       callback: poll(value, app).pipe(Effect.flatMap((tokens) => credential(deviceMethodID, tokens)))
     };
   })))),
-  refresh: (value) => refresh(deviceMethodID, exports_credential.OAuth.make({ ...value, methodID: deviceMethodID }), app)
+  refresh: (value) => refresh(deviceMethodID, OAuth3.make({ ...value, methodID: deviceMethodID }), app)
 });
-var XAIPlugin = define({
+var XAIPlugin2 = define({
   id: "opencode.provider.xai",
   effect: Effect.fn(function* (ctx) {
-    const credentials = yield* exports_credential.Service;
-    yield* Effect.forEach(yield* credentials.list(exports_integration.ID.make("xai")), (credential) => {
+    const credentials = yield* Service68;
+    yield* Effect.forEach(yield* credentials.list(ID5.make("xai")), (credential) => {
       if (credential.value.type !== "oauth" || credential.value.methodID !== browserMethodID)
         return Effect.void;
       return credentials.update(credential.id, {
-        value: exports_credential.OAuth.make({ ...credential.value, methodID: deviceMethodID })
+        value: OAuth3.make({ ...credential.value, methodID: deviceMethodID })
       });
     }, { discard: true });
     yield* ctx.integration.transform((editor) => {
@@ -104,10 +106,10 @@ function refresh(methodID, value, app) {
     }).toString()
   }, Token).pipe(Effect.flatMap((tokens) => credential(methodID, tokens, value.refresh, value.metadata)));
 }
-function poll(device2, app) {
+function poll(device, app) {
   return Effect.gen(function* () {
     const started = yield* Clock.currentTimeMillis;
-    const expires = started + positiveSeconds(device2.expires_in, 300) * 1000;
+    const expires = started + positiveSeconds(device.expires_in, 300) * 1000;
     const loop = (interval) => Effect.gen(function* () {
       if ((yield* Clock.currentTimeMillis) >= expires) {
         return yield* Effect.fail(new Error("xAI device authorization timed out"));
@@ -118,7 +120,7 @@ function poll(device2, app) {
         body: new URLSearchParams({
           grant_type: deviceGrant,
           client_id: clientID,
-          device_code: device2.device_code
+          device_code: device.device_code
         }).toString()
       });
       if (response.ok)
@@ -142,7 +144,7 @@ function poll(device2, app) {
       const detail = error?.error_description ?? error?.error;
       return yield* Effect.fail(new Error(`xAI device token exchange failed (${response.status})${detail ? `: ${detail}` : ""}`));
     });
-    return yield* loop(Math.max(positiveSeconds(device2.interval, 5) * 1000, 1000));
+    return yield* loop(Math.max(positiveSeconds(device.interval, 5) * 1000, 1000));
   });
 }
 function request(url, init, schema) {
@@ -162,13 +164,13 @@ function decode(response, schema) {
   return Effect.promise(() => response.json()).pipe(Effect.map(Schema.decodeUnknownSync(schema)));
 }
 function credential(methodID, tokens, currentRefresh, metadata) {
-  const refresh2 = tokens.refresh_token ?? currentRefresh;
-  if (!refresh2)
+  const refresh = tokens.refresh_token ?? currentRefresh;
+  if (!refresh)
     return Effect.fail(new Error("xAI token response is missing refresh_token"));
-  return Effect.succeed(exports_credential.OAuth.make({
+  return Effect.succeed(OAuth3.make({
     type: "oauth",
     methodID,
-    refresh: refresh2,
+    refresh,
     access: tokens.access_token,
     expires: tokenExpiration(tokens),
     metadata
@@ -188,7 +190,7 @@ function headers(app) {
   return {
     "Content-Type": "application/x-www-form-urlencoded",
     Accept: "application/json",
-    "User-Agent": exports_app.useragent(app)
+    "User-Agent": useragent2(app)
   };
 }
 function positiveSeconds(value, fallback) {
@@ -196,4 +198,4 @@ function positiveSeconds(value, fallback) {
   return Number.isFinite(seconds) && seconds > 0 ? seconds : fallback;
 }
 
-export { XAIPlugin };
+export { XAIPlugin2 };

package/dist/chunks/{schema-s7whb9gt.js → pty-822emrt2.js}

@@ -2,7 +2,7 @@
 import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
 import { entityKind } from "drizzle-orm/entity";
 
-class SQLiteEffectRaw {
+class SQLiteEffectRaw2 {
   execute;
   getSQL;
   action;
@@ -26,6 +26,6 @@ class SQLiteEffectRaw {
     return this;
   }
 }
-applyEffectWrapper(SQLiteEffectRaw);
+applyEffectWrapper(SQLiteEffectRaw2);
 
-export { SQLiteEffectRaw };
+export { SQLiteEffectRaw2 };

package/dist/chunks/{schema-8w9tzfz1.js → pty-88xbtdfr.js}

@@ -1,5 +1,5 @@
 // src/util/lazy.ts
-function lazy(fn) {
+function lazy2(fn) {
   let value;
   let loaded = false;
   return () => {
@@ -11,4 +11,4 @@ function lazy(fn) {
   };
 }
 
-export { lazy };
+export { lazy2 };

package/dist/chunks/pty-8w99qwke.js

@@ -0,0 +1,38 @@
+import {
+  Service62
+} from "./pty-amgxn0m4.js";
+import {
+  Service11
+} from "./pty-9d4vrqc0.js";
+import {
+  observe2
+} from "./pty-qsdy395h.js";
+import {
+  __export
+} from "./pty-9rqn6x4v.js";
+
+// src/config/plugin/location-watcher.ts
+var exports_location_watcher2 = {};
+__export(exports_location_watcher2, {
+  ConfigLocationWatcherPlugin: () => exports_location_watcher2,
+  Plugin: () => Plugin41
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect } from "effect";
+var Plugin41 = define({
+  id: "opencode.config.location-watcher",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service62;
+    const policy = yield* Service11;
+    const loaded = yield* observe2(config, ctx.event, policy.reload());
+    yield* policy.transform((editor) => {
+      for (const entry of loaded.entries) {
+        if (entry.type !== "document" || !entry.info.watcher?.ignore)
+          continue;
+        editor.add(entry.info.watcher.ignore);
+      }
+    });
+  })
+});
+
+export { Plugin41, exports_location_watcher2 };