@opencode-ai/core 0.0.0-dev-19087 → 0.0.0-dev-19093

package/dist/chunks/{instance-c54e84vp.js → kv-6e958v7x.js}

@@ -1,56 +1,56 @@
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/instructions/index.ts
-var exports_instructions = {};
-__export(exports_instructions, {
-  Delta: () => Delta,
-  DuplicateKeyError: () => DuplicateKeyError,
-  Hash: () => Hash,
-  InitializationBlocked: () => InitializationBlocked,
-  Instructions: () => exports_instructions,
-  Key: () => Key,
-  Values: () => Values,
-  applyHashDelta: () => applyHashDelta,
-  combine: () => combine,
-  diff: () => diff,
-  diffByKey: () => diffByKey,
-  empty: () => empty,
-  hash: () => hash,
-  make: () => make,
-  read: () => read,
-  removed: () => removed,
-  renderInitial: () => renderInitial,
-  renderUpdate: () => renderUpdate,
-  unavailable: () => unavailable
+var exports_instructions6 = {};
+__export(exports_instructions6, {
+  Delta: () => Delta2,
+  DuplicateKeyError: () => DuplicateKeyError2,
+  Hash: () => Hash2,
+  InitializationBlocked: () => InitializationBlocked2,
+  Instructions: () => exports_instructions6,
+  Key: () => Key3,
+  Values: () => Values2,
+  applyHashDelta: () => applyHashDelta2,
+  combine: () => combine2,
+  diff: () => diff2,
+  diffByKey: () => diffByKey2,
+  empty: () => empty3,
+  hash: () => hash2,
+  make: () => make19,
+  read: () => read3,
+  removed: () => removed2,
+  renderInitial: () => renderInitial2,
+  renderUpdate: () => renderUpdate2,
+  unavailable: () => unavailable3
 });
 import { createHash } from "crypto";
 import { Instruction } from "@opencode-ai/schema/instruction";
 import { Data, Effect, Option, Schema } from "effect";
-var Key = Instruction.Key;
-var Hash = Instruction.Hash;
-var Values = Instruction.Values;
-var Delta = Instruction.Delta;
+var Key3 = Instruction.Key;
+var Hash2 = Instruction.Hash;
+var Values2 = Instruction.Values;
+var Delta2 = Instruction.Delta;
 var NonValue = Data.taggedEnum();
-var unavailable = NonValue.Unavailable();
-var removed = NonValue.Removed();
+var unavailable3 = NonValue.Unavailable();
+var removed2 = NonValue.Removed();
 
-class InitializationBlocked extends Schema.TaggedError()("Instructions.InitializationBlocked", { keys: Schema.Array(Key) }) {
+class InitializationBlocked2 extends Schema.TaggedError()("Instructions.InitializationBlocked", { keys: Schema.Array(Key3) }) {
   get message() {
     return `Instruction initialization blocked by unavailable sources: ${this.keys.join(", ")}`;
   }
 }
 
-class DuplicateKeyError extends Schema.TaggedError()("Instructions.DuplicateKeyError", {
-  key: Key
+class DuplicateKeyError2 extends Schema.TaggedError()("Instructions.DuplicateKeyError", {
+  key: Key3
 }) {
   get message() {
     return `Duplicate instruction key: ${this.key}`;
   }
 }
-var empty = [];
-function make(source) {
+var empty3 = [];
+function make19(source) {
   const decode = Schema.decodeUnknownOption(source.codec);
   const encode = Schema.encodeSync(source.codec);
   const initial = (value) => requireText(source.key, "initial", source.render.initial(value));
@@ -60,9 +60,9 @@ function make(source) {
       key: source.key,
       read: source.read.pipe(Effect.map((value) => {
         if (isUnavailable(value))
-          return unavailable;
+          return unavailable3;
         if (isRemoved(value))
-          return removed;
+          return removed2;
         return encode(value);
       })),
       initial: (value) => {
@@ -85,23 +85,23 @@ function make(source) {
     }
   ];
 }
-function combine(values) {
+function combine2(values) {
   const sources = values.flat();
   const keys = new Set;
   for (const source of sources) {
     if (keys.has(source.key))
-      throw new DuplicateKeyError({ key: source.key });
+      throw new DuplicateKeyError2({ key: source.key });
     keys.add(source.key);
   }
   return sources;
 }
-function read(value) {
+function read3(value) {
   return Effect.forEach(value, (source) => source.read.pipe(Effect.map((observed) => ({ key: source.key, value: observed }))), { concurrency: "unbounded" });
 }
-function diff(observed, previous) {
+function diff2(observed, previous) {
   const blocked = previous ? [] : observed.flatMap((entry) => isUnavailable(entry.value) ? [entry.key] : []);
   if (blocked.length > 0)
-    return Effect.fail(new InitializationBlocked({ keys: blocked }));
+    return Effect.fail(new InitializationBlocked2({ keys: blocked }));
   const delta = {};
   const blobs = {};
   for (const entry of observed) {
@@ -112,7 +112,7 @@ function diff(observed, previous) {
         delta[entry.key] = Instruction.removed;
       continue;
     }
-    const next = hash(entry.value);
+    const next = hash2(entry.value);
     if (previous?.[entry.key] === next)
       continue;
     delta[entry.key] = next;
@@ -120,7 +120,7 @@ function diff(observed, previous) {
   }
   return Effect.succeed({ delta, blobs });
 }
-function renderInitial(value, values) {
+function renderInitial2(value, values) {
   return render(value.flatMap((source) => {
     if (!Object.hasOwn(values, source.key))
       return [];
@@ -128,7 +128,7 @@ function renderInitial(value, values) {
     return text === undefined ? [] : [text];
   }));
 }
-function renderUpdate(value, previous, delta) {
+function renderUpdate2(value, previous, delta) {
   return render(value.flatMap((source) => {
     if (!Object.hasOwn(delta, source.key))
       return [];
@@ -136,18 +136,18 @@ function renderUpdate(value, previous, delta) {
     if (Option.isNone(current)) {
       if (!Object.hasOwn(previous, source.key))
         return [];
-      const text2 = source.removed(previous[source.key]);
-      return text2 === undefined ? [] : [text2];
+      const text = source.removed(previous[source.key]);
+      return text === undefined ? [] : [text];
     }
     const next = current.value;
     const text = Object.hasOwn(previous, source.key) ? source.changed(previous[source.key], next) : source.initial(next);
     return text === undefined ? [] : [text];
   }));
 }
-function hash(value) {
-  return Hash.make(createHash("sha256").update(canonical(value)).digest("hex"));
+function hash2(value) {
+  return Hash2.make(createHash("sha256").update(canonical(value)).digest("hex"));
 }
-function applyHashDelta(values, delta) {
+function applyHashDelta2(values, delta) {
   const result = { ...values };
   for (const [key, value] of Object.entries(delta)) {
     if (value === Instruction.removed)
@@ -157,7 +157,7 @@ function applyHashDelta(values, delta) {
   }
   return result;
 }
-function diffByKey(previous, current, key, changed) {
+function diffByKey2(previous, current, key, changed) {
   const currentKeys = new Set(current.map(key));
   const previousByKey = new Map(previous.map((value) => [key(value), value]));
   return {
@@ -175,10 +175,10 @@ function render(parts) {
 `);
 }
 function isUnavailable(value) {
-  return value === unavailable;
+  return value === unavailable3;
 }
 function isRemoved(value) {
-  return value === removed;
+  return value === removed2;
 }
 function canonical(value) {
   if (Array.isArray(value))
@@ -193,4 +193,4 @@ function requireText(key, kind, text) {
   return text;
 }
 
-export { Key, Hash, Values, Delta, unavailable, removed, InitializationBlocked, DuplicateKeyError, empty, make, combine, read, diff, renderInitial, renderUpdate, hash, applyHashDelta, diffByKey, exports_instructions };
+export { Key3, Hash2, Values2, Delta2, unavailable3, removed2, InitializationBlocked2, DuplicateKeyError2, empty3, make19, combine2, read3, diff2, renderInitial2, renderUpdate2, hash2, applyHashDelta2, diffByKey2, exports_instructions6 };

package/dist/chunks/{instance-xmp1dk6d.js → kv-6h1zm1av.js}

@@ -1,30 +1,32 @@
 import {
-  exports_entry_observer
-} from "./instance-mnyszbxc.js";
+  mergeOverlay2,
+  mergeHeaders2
+} from "./kv-64z8z5x5.js";
 import {
-  exports_config
-} from "./instance-rksay3ym.js";
+  latest2,
+  Service50
+} from "./kv-7m27rx9w.js";
 import {
-  exports_provider
-} from "./instance-68yag814.js";
+  observe2
+} from "./kv-qsdy395h.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/config/plugin/provider.ts
-var exports_provider2 = {};
-__export(exports_provider2, {
-  ConfigProviderPlugin: () => exports_provider2,
-  Plugin: () => Plugin
+var exports_provider = {};
+__export(exports_provider, {
+  ConfigProviderPlugin: () => exports_provider,
+  Plugin: () => Plugin15
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Money } from "@opencode-ai/schema/money";
 import { Effect } from "effect";
-var Plugin = define({
+var Plugin15 = define({
   id: "opencode.config.provider",
   effect: Effect.fn(function* (ctx) {
-    const config = yield* exports_config.Service;
-    const loaded = yield* exports_entry_observer.observe(config, ctx.event, ctx.integration.reload().pipe(Effect.andThen(ctx.catalog.reload())));
+    const config = yield* Service50;
+    const loaded = yield* observe2(config, ctx.event, ctx.integration.reload().pipe(Effect.andThen(ctx.catalog.reload())));
     yield* ctx.integration.transform((integrations) => {
       for (const [id, provider] of configuredProviders(loaded.entries)) {
         const integrationID = id;
@@ -46,7 +48,7 @@ var Plugin = define({
       }
     });
     yield* ctx.catalog.transform((catalog) => {
-      const configuredDefault = exports_config.latest(loaded.entries, "model");
+      const configuredDefault = latest2(loaded.entries, "model");
       if (configuredDefault !== undefined)
         catalog.model.default.set(configuredDefault.providerID, configuredDefault.model);
       for (const [id, item] of configuredProviders(loaded.entries)) {
@@ -68,16 +70,16 @@ var Plugin = define({
           if (item.package !== undefined)
             provider.package = item.package;
           if (item.settings !== undefined)
-            provider.settings = exports_provider.mergeOverlay(provider.settings, item.settings);
+            provider.settings = mergeOverlay2(provider.settings, item.settings);
           if (item.headers !== undefined)
-            provider.headers = exports_provider.mergeHeaders(provider.headers, item.headers);
+            provider.headers = mergeHeaders2(provider.headers, item.headers);
           if (item.body !== undefined)
-            provider.body = exports_provider.mergeOverlay(provider.body, item.body);
+            provider.body = mergeOverlay2(provider.body, item.body);
         });
-        for (const [id2, config2] of Object.entries(item.models ?? {})) {
-          const base = source?.models.get(config2.modelID ?? id2) ?? source?.models.get(id2);
-          const inherit = changed || !catalog.model.get(providerID, id2);
-          catalog.model.update(providerID, id2, (model) => {
+        for (const [id, config] of Object.entries(item.models ?? {})) {
+          const base = source?.models.get(config.modelID ?? id) ?? source?.models.get(id);
+          const inherit = changed || !catalog.model.get(providerID, id);
+          catalog.model.update(providerID, id, (model) => {
             if (inherit && base) {
               Object.assign(model, structuredClone(base));
               if (item.package !== undefined)
@@ -85,47 +87,47 @@ var Plugin = define({
               if (item.settings?.baseURL !== undefined && model.settings)
                 delete model.settings.baseURL;
             }
-            if (config2.family !== undefined)
-              model.family = config2.family;
-            if (config2.name !== undefined)
-              model.name = config2.name;
-            if (config2.modelID !== undefined)
-              model.modelID = config2.modelID;
-            if (config2.compatibility !== undefined)
-              model.compatibility = { ...model.compatibility, ...config2.compatibility };
-            if (config2.package !== undefined)
-              model.package = config2.package;
-            if (config2.settings !== undefined)
-              model.settings = exports_provider.mergeOverlay(model.settings, config2.settings);
-            if (config2.headers !== undefined)
-              model.headers = exports_provider.mergeHeaders(model.headers, config2.headers);
-            if (config2.body !== undefined)
-              model.body = exports_provider.mergeOverlay(model.body, config2.body);
-            if (config2.capabilities !== undefined) {
+            if (config.family !== undefined)
+              model.family = config.family;
+            if (config.name !== undefined)
+              model.name = config.name;
+            if (config.modelID !== undefined)
+              model.modelID = config.modelID;
+            if (config.compatibility !== undefined)
+              model.compatibility = { ...model.compatibility, ...config.compatibility };
+            if (config.package !== undefined)
+              model.package = config.package;
+            if (config.settings !== undefined)
+              model.settings = mergeOverlay2(model.settings, config.settings);
+            if (config.headers !== undefined)
+              model.headers = mergeHeaders2(model.headers, config.headers);
+            if (config.body !== undefined)
+              model.body = mergeOverlay2(model.body, config.body);
+            if (config.capabilities !== undefined) {
               model.capabilities = {
-                tools: config2.capabilities.tools,
-                input: [...config2.capabilities.input],
-                output: [...config2.capabilities.output]
+                tools: config.capabilities.tools,
+                input: [...config.capabilities.input],
+                output: [...config.capabilities.output]
               };
             }
-            if (config2.variants !== undefined) {
+            if (config.variants !== undefined) {
               model.variants ??= [];
-              for (const variant of config2.variants) {
-                let existing = model.variants.find((item2) => item2.id === variant.id);
+              for (const variant of config.variants) {
+                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, variant.settings);
+                  existing.settings = mergeOverlay2(existing.settings, 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, variant.body);
+                  existing.body = mergeOverlay2(existing.body, variant.body);
               }
             }
-            if (config2.cost !== undefined) {
-              model.cost = (Array.isArray(config2.cost) ? config2.cost : [config2.cost]).map((cost) => ({
+            if (config.cost !== undefined) {
+              model.cost = (Array.isArray(config.cost) ? config.cost : [config.cost]).map((cost) => ({
                 tier: cost.tier && { ...cost.tier },
                 input: cost.input,
                 output: cost.output,
@@ -135,10 +137,10 @@ var Plugin = define({
                 }
               }));
             }
-            if (config2.disabled !== undefined)
-              model.enabled = !config2.disabled;
-            if (config2.limit !== undefined)
-              model.limit = { ...model.limit, ...config2.limit };
+            if (config.disabled !== undefined)
+              model.enabled = !config.disabled;
+            if (config.limit !== undefined)
+              model.limit = { ...model.limit, ...config.limit };
           });
         }
       }
@@ -149,4 +151,4 @@ function configuredProviders(entries) {
   return entries.filter((entry) => entry.type === "document").flatMap((file) => Object.entries(file.info.providers ?? {}));
 }
 
-export { Plugin, exports_provider2 as exports_provider };
+export { Plugin15, exports_provider };

package/dist/chunks/{instance-bd2mvb8t.js → kv-6h414ywr.js}

@@ -1,21 +1,21 @@
 import {
-  PositiveInt
-} from "./instance-j07kk359.js";
+  PositiveInt2
+} from "./kv-p8qxwesx.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/v1/config/mcp.ts
-var exports_mcp = {};
-__export(exports_mcp, {
-  ConfigMCPV1: () => exports_mcp,
-  Info: () => Info,
-  Local: () => Local,
-  OAuth: () => OAuth,
-  Remote: () => Remote
+var exports_mcp5 = {};
+__export(exports_mcp5, {
+  ConfigMCPV1: () => exports_mcp5,
+  Info: () => Info13,
+  Local: () => Local2,
+  OAuth: () => OAuth2,
+  Remote: () => Remote2
 });
 import { Schema } from "effect";
-var Local = Schema.Struct({
+var Local2 = Schema.Struct({
   type: Schema.Literal("local").annotate({ description: "Type of MCP server connection" }),
   command: Schema.mutable(Schema.Array(Schema.String)).annotate({
     description: "Command and arguments to run the MCP server"
@@ -29,11 +29,11 @@ var Local = Schema.Struct({
   enabled: Schema.optional(Schema.Boolean).annotate({
     description: "Enable or disable the MCP server on startup"
   }),
-  timeout: Schema.optional(PositiveInt).annotate({
+  timeout: Schema.optional(PositiveInt2).annotate({
     description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified."
   })
 }).annotate({ identifier: "McpLocalConfig" });
-var OAuth = Schema.Struct({
+var OAuth2 = Schema.Struct({
   clientId: Schema.optional(Schema.String).annotate({
     description: "OAuth client ID. If not provided, dynamic client registration (RFC 7591) will be attempted."
   }),
@@ -48,7 +48,7 @@ var OAuth = Schema.Struct({
     description: "OAuth redirect URI (default: http://127.0.0.1:19876/mcp/oauth/callback)."
   })
 }).annotate({ identifier: "McpOAuthConfig" });
-var Remote = Schema.Struct({
+var Remote2 = Schema.Struct({
   type: Schema.Literal("remote").annotate({ description: "Type of MCP server connection" }),
   url: Schema.String.annotate({ description: "URL of the remote MCP server" }),
   enabled: Schema.optional(Schema.Boolean).annotate({
@@ -57,13 +57,13 @@ var Remote = Schema.Struct({
   headers: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
     description: "Headers to send with the request"
   }),
-  oauth: Schema.optional(Schema.Union([OAuth, Schema.Literal(false)])).annotate({
+  oauth: Schema.optional(Schema.Union([OAuth2, Schema.Literal(false)])).annotate({
     description: "OAuth authentication configuration for the MCP server. Set to false to disable OAuth auto-detection."
   }),
-  timeout: Schema.optional(PositiveInt).annotate({
+  timeout: Schema.optional(PositiveInt2).annotate({
     description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified."
   })
 }).annotate({ identifier: "McpRemoteConfig" });
-var Info = Schema.Union([Local, Remote]).annotate({ discriminator: "type" });
+var Info13 = Schema.Union([Local2, Remote2]).annotate({ discriminator: "type" });
 
-export { Local, OAuth, Remote, Info, exports_mcp };
+export { Local2, OAuth2, Remote2, Info13, exports_mcp5 };

package/dist/chunks/{instance-c77ad0vh.js → kv-6prwharc.js}

@@ -1,6 +1,6 @@
 // src/tool/plugin/file-diff.ts
 import { createTwoFilesPatch, diffLines } from "diff";
-function fileDiff(file, before, after, status = "modified") {
+function fileDiff2(file, before, after, status = "modified") {
   const counts = diffLines(before, after).reduce((result, item) => ({
     additions: result.additions + (item.added ? item.count ?? 0 : 0),
     deletions: result.deletions + (item.removed ? item.count ?? 0 : 0)
@@ -13,4 +13,4 @@ function fileDiff(file, before, after, status = "modified") {
   };
 }
 
-export { fileDiff };
+export { fileDiff2 };

package/dist/chunks/{instance-svrgfpe2.js → kv-6tf8tr4v.js}

@@ -1,17 +1,17 @@
 import {
-  definition,
-  normalizedName
-} from "./instance-xx9qfgev.js";
+  definition2,
+  normalizedName2
+} from "./kv-3t738kvx.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/codemode/tool.ts
-var exports_tool = {};
-__export(exports_tool, {
-  CodeModeTool: () => exports_tool,
-  catalog: () => catalog,
-  create: () => create
+var exports_tool2 = {};
+__export(exports_tool2, {
+  CodeModeTool: () => exports_tool2,
+  catalog: () => catalog2,
+  create: () => create2
 });
 import { CodeMode, Namespace, Tool, toolError } from "@opencode-ai/codemode";
 import { Effect, Ref, Schema, Semaphore } from "effect";
@@ -40,7 +40,7 @@ var description = [
   "Await every call whose completion matters; pending calls are interrupted when execution ends. Run independent calls concurrently with `Promise.all`."
 ].join(`
 `);
-var create = (inventory, executeTool) => {
+var create2 = (inventory, executeTool) => {
   return {
     name: "execute",
     description,
@@ -51,17 +51,17 @@ var create = (inventory, executeTool) => {
       const files = yield* Ref.make([]);
       const calls = yield* Ref.make([]);
       const lock = Semaphore.makeUnsafe(1);
-      const updateCalls = (update) => lock.withPermit(Ref.updateAndGet(calls, update).pipe(Effect.flatMap((toolCalls2) => context.progress({ toolCalls: toolCalls2 }))));
+      const updateCalls = (update) => lock.withPermit(Ref.updateAndGet(calls, update).pipe(Effect.flatMap((toolCalls) => context.progress({ toolCalls }))));
       const result = yield* runtime(inventory, (name, tool, input) => Effect.gen(function* () {
-        const index = yield* Ref.getAndUpdate(callIndex, (index2) => index2 + 1);
+        const index = yield* Ref.getAndUpdate(callIndex, (index) => index + 1);
         const executed = yield* executeTool(name, tool, input, context);
-        const content2 = typeof executed.content === "string" ? [{ type: "text", text: executed.content }] : executed.content ?? [];
-        const outputFileParts = outputFiles(content2);
+        const content = typeof executed.content === "string" ? [{ type: "text", text: executed.content }] : executed.content ?? [];
+        const outputFileParts = outputFiles(content);
         if (outputFileParts.length > 0)
           yield* Ref.update(files, (items) => [...items, { index, files: outputFileParts }]);
         if (executed.output !== undefined)
           return executed.output;
-        const text = content2.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+        const text = content.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
 `);
         return text === "" ? null : text;
       }), {
@@ -115,7 +115,7 @@ var create = (inventory, executeTool) => {
     })
   };
 };
-var catalog = (inventory) => {
+var catalog2 = (inventory) => {
   const pinned = new Set(Array.from(inventory.tools.values()).filter((registration) => registration.options?.pinned === true).map(qualifiedName));
   const root = { children: new Map };
   for (const namespace of inventory.namespaces?.values() ?? [])
@@ -153,7 +153,7 @@ function runtime(inventory, executeTool, hooks) {
   for (const namespace of inventory.namespaces?.values() ?? [])
     getNode(root, namespace.name).namespace = namespace;
   for (const [name, registration] of inventory.tools) {
-    const child = definition(registration);
+    const child = definition2(registration);
     getNode(root, qualifiedName(registration)).tool = Tool.make({
       description: child.description,
       input: child.inputSchema,
@@ -211,7 +211,7 @@ function flattenTools(node, path, tools) {
     flattenTools(child, [...path, name], tools);
 }
 function qualifiedName(registration) {
-  const normalized = normalizedName(registration);
+  const normalized = normalizedName2(registration);
   if (registration.options?.namespace === undefined)
     return normalized;
   return `${registration.options.namespace}.${normalized}`;
@@ -260,4 +260,4 @@ function outputFiles(content) {
   });
 }
 
-export { create, catalog, exports_tool };
+export { create2, catalog2, exports_tool2 };

package/dist/chunks/{instance-my7754jk.js → kv-6ycxekxv.js}

@@ -1,33 +1,33 @@
 import {
-  exports_entry_observer
-} from "./instance-mnyszbxc.js";
+  Service50
+} from "./kv-7m27rx9w.js";
 import {
-  exports_wildcard
-} from "./instance-edxnhgvj.js";
+  match2
+} from "./kv-y1fvbwt7.js";
 import {
-  exports_config
-} from "./instance-rksay3ym.js";
+  observe2
+} from "./kv-qsdy395h.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/config/plugin/policy.ts
 var exports_policy = {};
 __export(exports_policy, {
   ConfigPolicyPlugin: () => exports_policy,
-  Plugin: () => Plugin
+  Plugin: () => Plugin24
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect } from "effect";
-var Plugin = define({
+var Plugin24 = define({
   id: "opencode.config.policy",
   effect: Effect.fn(function* (ctx) {
-    const config = yield* exports_config.Service;
-    const loaded = yield* exports_entry_observer.observe(config, ctx.event, ctx.catalog.reload());
+    const config = yield* Service50;
+    const loaded = yield* observe2(config, ctx.event, ctx.catalog.reload());
     yield* ctx.catalog.transform((catalog) => {
       const policies = loaded.entries.filter((entry) => entry.type === "document").toReversed().flatMap((entry) => entry.info.experimental?.policies ?? []);
       for (const record of catalog.provider.list()) {
-        const policy = policies.findLast((policy2) => exports_wildcard.match(record.provider.id, policy2.resource));
+        const policy = policies.findLast((policy) => match2(record.provider.id, policy.resource));
         if (policy?.effect === "deny")
           catalog.provider.remove(record.provider.id);
       }
@@ -35,4 +35,4 @@ var Plugin = define({
   })
 });
 
-export { Plugin, exports_policy };
+export { Plugin24, exports_policy };