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

package/dist/chunks/{instance-k9d5hcgq.js → kv-n08wtfc0.js}

@@ -1,71 +1,73 @@
 import {
-  exports_kv
-} from "./instance-qtvzgpey.js";
+  Service79,
+  node83
+} from "./kv-9j3fyze8.js";
 import {
-  exports_state
-} from "./instance-j6s3yjyb.js";
+  Service68,
+  node72
+} from "./kv-keptat7v.js";
 import {
-  exports_bus
-} from "./instance-3dwd52hd.js";
+  create3
+} from "./kv-kg06axw8.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/websearch.ts
-var exports_websearch = {};
-__export(exports_websearch, {
-  DisabledError: () => DisabledError,
-  Event: () => Event,
-  ID: () => ID,
-  Input: () => Input,
-  Provider: () => Provider,
-  ProviderKey: () => ProviderKey,
-  ProviderNotFoundError: () => ProviderNotFoundError,
-  ProviderRequiredError: () => ProviderRequiredError,
-  RequestError: () => RequestError,
-  Response: () => Response,
-  Result: () => Result,
-  Selection: () => Selection,
-  Service: () => Service,
-  WebSearch: () => exports_websearch,
-  node: () => node
+var exports_websearch3 = {};
+__export(exports_websearch3, {
+  DisabledError: () => DisabledError2,
+  Event: () => Event5,
+  ID: () => ID3,
+  Input: () => Input13,
+  Provider: () => Provider2,
+  ProviderKey: () => ProviderKey2,
+  ProviderNotFoundError: () => ProviderNotFoundError2,
+  ProviderRequiredError: () => ProviderRequiredError2,
+  RequestError: () => RequestError2,
+  Response: () => Response2,
+  Result: () => Result2,
+  Selection: () => Selection2,
+  Service: () => Service18,
+  WebSearch: () => exports_websearch3,
+  node: () => node21
 });
 import { WebSearch } from "@opencode-ai/schema/websearch";
 import { Context, Effect, Layer, Option, Schema } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
-import { Event } from "@opencode-ai/schema/websearch";
-var ID = WebSearch.ID;
-var Provider = WebSearch.Provider;
-var Input = WebSearch.Input;
-var Result = WebSearch.Result;
-var Response = WebSearch.Response;
-var ProviderKey = "websearch:provider";
-var Selection = Schema.Union([ID, Schema.Literal("random"), Schema.Literal(false)]);
+import { Event as Event5 } from "@opencode-ai/schema/websearch";
+var ID3 = WebSearch.ID;
+var Provider2 = WebSearch.Provider;
+var Input13 = WebSearch.Input;
+var Result2 = WebSearch.Result;
+var Response2 = WebSearch.Response;
+var ProviderKey2 = "websearch:provider";
+var Selection2 = Schema.Union([ID3, Schema.Literal("random"), Schema.Literal(false)]);
 
-class ProviderRequiredError extends Schema.TaggedError()("WebSearch.ProviderRequired", {}) {
+class ProviderRequiredError2 extends Schema.TaggedError()("WebSearch.ProviderRequired", {}) {
 }
 
-class ProviderNotFoundError extends Schema.TaggedError()("WebSearch.ProviderNotFound", {
-  providerID: ID
+class ProviderNotFoundError2 extends Schema.TaggedError()("WebSearch.ProviderNotFound", {
+  providerID: ID3
 }) {
 }
 
-class DisabledError extends Schema.TaggedError()("WebSearch.Disabled", {}) {
+class DisabledError2 extends Schema.TaggedError()("WebSearch.Disabled", {}) {
 }
 
-class RequestError extends Schema.TaggedError()("WebSearch.Request", {
-  providerID: ID,
+class RequestError2 extends Schema.TaggedError()("WebSearch.Request", {
+  providerID: ID3,
   cause: Schema.Defect()
 }) {
 }
 
-class Service extends Context.Service()("@opencode/WebSearch") {
+class Service18 extends Context.Service()("@opencode/WebSearch") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const bus = yield* exports_bus.Service;
-  const kv = yield* exports_kv.Service;
-  const decodeResults = Schema.decodeUnknownEffect(Schema.Array(Result));
-  const state = exports_state.create({
+var layer = Layer.effect(Service18, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const kv = yield* Service68;
+  const decodeResults = Schema.decodeUnknownEffect(Schema.Array(Result2));
+  const state = create3({
     initial: () => ({ providers: new Map }),
     editor: (editor) => ({
       add: (provider) => editor.providers.set(provider.id, provider),
@@ -78,17 +80,17 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   });
   const requireProvider = (providers, providerID) => {
     const provider = providers.get(providerID);
-    return provider ? Effect.succeed(provider) : Effect.fail(new ProviderNotFoundError({ providerID }));
+    return provider ? Effect.succeed(provider) : Effect.fail(new ProviderNotFoundError2({ providerID }));
   };
   const defaultProvider = Effect.fn("WebSearch.default")(function* () {
     const data = state.get();
-    const stored = data.selection === undefined ? yield* kv.get(ProviderKey) : undefined;
-    const decoded = Schema.decodeUnknownOption(Selection)(stored);
+    const stored = data.selection === undefined ? yield* kv.get(ProviderKey2) : undefined;
+    const decoded = Schema.decodeUnknownOption(Selection2)(stored);
     if (stored !== undefined && Option.isNone(decoded))
-      yield* kv.remove(ProviderKey);
+      yield* kv.remove(ProviderKey2);
     const selection = data.selection ?? Option.getOrUndefined(decoded);
     if (selection === false)
-      return yield* new DisabledError;
+      return yield* new DisabledError2;
     if (selection === "random") {
       const providers = Array.from(data.providers.values());
       return providers[Math.floor(Math.random() * providers.length)];
@@ -101,10 +103,10 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       return yield* requireProvider(providers, input.providerID);
     const provider = yield* defaultProvider();
     if (!provider)
-      return yield* new ProviderRequiredError;
+      return yield* new ProviderRequiredError2;
     return provider;
   });
-  return Service.of({
+  return Service18.of({
     transform: state.transform,
     reload: state.reload,
     providers: Effect.fn("WebSearch.providers")(function* () {
@@ -118,19 +120,19 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       return provider && { id: provider.id, name: provider.name };
     }),
     select: Effect.fn("WebSearch.select")(function* (selection) {
-      yield* kv.set(ProviderKey, selection);
+      yield* kv.set(ProviderKey2, selection);
     }),
     query: Effect.fn("WebSearch.query")(function* (input) {
       const provider = yield* resolve(input);
-      const results = yield* provider.execute({ query: input.query }).pipe(Effect.flatMap(decodeResults), Effect.mapError((cause) => new RequestError({ providerID: provider.id, cause })));
-      return new Response({ providerID: provider.id, results });
+      const results = yield* provider.execute({ query: input.query }).pipe(Effect.flatMap(decodeResults), Effect.mapError((cause) => new RequestError2({ providerID: provider.id, cause })));
+      return new Response2({ providerID: provider.id, results });
     })
   });
 }));
-var node = makeLocationNode({
-  service: Service,
+var node21 = makeLocationNode({
+  service: Service18,
   layer,
-  deps: [exports_bus.node, exports_kv.node]
+  deps: [node83, node72]
 });
 
-export { ID, Provider, Input, Result, Response, ProviderKey, Selection, ProviderRequiredError, ProviderNotFoundError, DisabledError, RequestError, Service, node, exports_websearch, Event };
+export { ID3, Provider2, Input13, Result2, Response2, ProviderKey2, Selection2, ProviderRequiredError2, ProviderNotFoundError2, DisabledError2, RequestError2, Service18, node21, exports_websearch3, Event5 };

package/dist/chunks/kv-n4qddg0w.js

@@ -0,0 +1,39 @@
+import {
+  Service46
+} from "./kv-4qjr8vj0.js";
+import {
+  Service40
+} from "./kv-sp5wnj6d.js";
+import {
+  awaitActivation2
+} from "./kv-jqh9b0xq.js";
+import {
+  __export
+} from "./kv-9rqn6x4v.js";
+
+// src/session/command.ts
+var exports_command3 = {};
+__export(exports_command3, {
+  SessionCommand: () => exports_command3,
+  execute: () => execute2
+});
+import { Effect } from "effect";
+var execute2 = Effect.fn("SessionCommand.execute")(function* (input) {
+  const instances = yield* Service40;
+  const commands = yield* awaitActivation2.pipe(Effect.andThen(Service46), instances.provide(input.session));
+  yield* commands.execute({
+    name: input.command,
+    invocation: {
+      sessionID: input.session.id,
+      prompt: {
+        text: input.text,
+        files: input.files,
+        agents: input.agents,
+        skills: input.skills
+      },
+      delivery: input.delivery ?? "steer"
+    }
+  });
+});
+
+export { execute2, exports_command3 };

package/dist/chunks/{instance-bacxzeht.js → kv-nc7q88x6.js}

@@ -1,76 +1,83 @@
 import {
-  exports_location_mutation
-} from "./instance-qqbvr2v1.js";
+  typeFollowing2
+} from "./kv-2a5m3afh.js";
 import {
-  exports_permission
-} from "./instance-enjmckgs.js";
+  RelativePath2
+} from "./kv-p8qxwesx.js";
 import {
-  exports_filesystem
-} from "./instance-1b3ejbt8.js";
+  Service70
+} from "./kv-c7r09442.js";
 import {
-  exports_ripgrep
-} from "./instance-88hamw33.js";
+  Service62
+} from "./kv-94exngkb.js";
 import {
-  exports_environment1 as exports_environment
-} from "./instance-qzx3gxz5.js";
+  Service61
+} from "./kv-tk0q86eg.js";
 import {
-  exports_location
-} from "./instance-0xgrsc61.js";
+  DEFAULT_SEARCH_LIMIT2,
+  DEFAULT_SEARCH_TIMEOUT_MS2,
+  GlobInput2,
+  Entry4
+} from "./kv-sdrecbr4.js";
 import {
-  RelativePath
-} from "./instance-j07kk359.js";
+  externalDirectoryPermission2,
+  Service15
+} from "./kv-j0msafmp.js";
+import {
+  Service53
+} from "./kv-nsdz1sxb.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/tool/plugin/glob.ts
 var exports_glob = {};
 __export(exports_glob, {
   GlobTool: () => exports_glob,
-  Input: () => Input,
-  Output: () => Output,
-  Plugin: () => Plugin,
-  name: () => name,
-  toModelContent: () => toModelContent
+  Input: () => Input8,
+  Output: () => Output5,
+  Plugin: () => Plugin9,
+  name: () => name8,
+  toModelContent: () => toModelContent3
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { Effect, Schema } from "effect";
 import path from "path";
-var name = "glob";
-var Input = Schema.Struct({
-  pattern: exports_filesystem.GlobInput.fields.pattern.annotate({ description: "Glob pattern to match files against" }),
-  path: Schema.optionalKey(RelativePath).annotate({
+var name8 = "glob";
+var Input8 = Schema.Struct({
+  pattern: GlobInput2.fields.pattern.annotate({ description: "Glob pattern to match files against" }),
+  path: Schema.optionalKey(RelativePath2).annotate({
     description: "Directory to search. Defaults to the current working directory."
   }),
-  hidden: exports_filesystem.GlobInput.fields.hidden.annotate({
+  hidden: GlobInput2.fields.hidden.annotate({
     description: "Include hidden files and directories (default: false)."
   }),
-  limit: exports_filesystem.GlobInput.fields.limit.annotate({
-    description: `Maximum number of matching files to return (default: ${exports_filesystem.DEFAULT_SEARCH_LIMIT})`
+  limit: GlobInput2.fields.limit.annotate({
+    description: `Maximum number of matching files to return (default: ${DEFAULT_SEARCH_LIMIT2})`
   })
 });
-var Output = Schema.Array(exports_filesystem.Entry);
-var toModelContent = (entries, truncated = false) => {
+var Output5 = Schema.Array(Entry4);
+var toModelContent3 = (entries, truncated = false) => {
   const lines = entries.length === 0 ? ["No files found"] : entries.map((item) => item.path);
   if (truncated)
     lines.push("", `(Results are truncated: showing first ${entries.length} results. Consider using a more specific path or pattern.)`);
   return lines.join(`
 `);
 };
-var Plugin = {
+var Plugin9 = {
   id: "opencode.tool.glob",
   effect: Effect.fn("GlobTool.Plugin")(function* (ctx) {
-    const environment = yield* exports_environment.Service;
-    const ripgrep = yield* exports_ripgrep.Service;
-    const location = yield* exports_location.Service;
-    const mutation = yield* exports_location_mutation.Service;
-    const permission = yield* exports_permission.Service;
+    const environment = yield* Service62;
+    const ripgrep = yield* Service61;
+    const location = yield* Service70;
+    const mutation = yield* Service15;
+    const permission = yield* Service53;
     yield* ctx.tool.transform((editor) => editor.add({
-      name,
+      name: name8,
       options: { codemode: false },
       description: 'Search file paths using a glob pattern (examples: "**/*.ts", "src/**/*.tsx").',
-      input: Input,
-      output: Output,
+      input: Input8,
+      output: Output5,
       execute: (input, context) => Effect.gen(function* () {
         const searchPath = input.path === "undefined" || input.path === "null" ? undefined : input.path;
         const source = { type: "tool", messageID: context.messageID, id: context.id };
@@ -78,13 +85,13 @@ var Plugin = {
         const external = target.externalDirectory;
         if (external)
           yield* permission.assert({
-            ...exports_location_mutation.externalDirectoryPermission(external),
+            ...externalDirectoryPermission2(external),
             sessionID: context.sessionID,
             agent: context.agent,
             source
           });
         yield* permission.assert({
-          action: name,
+          action: name8,
           resources: [input.pattern],
           save: ["*"],
           metadata: {
@@ -97,33 +104,33 @@ var Plugin = {
           agent: context.agent,
           source
         });
-        const type = yield* exports_environment.typeFollowing(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `Search path does not exist: ${searchPath ?? "."}` }))));
+        const type = yield* typeFollowing2(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `Search path does not exist: ${searchPath ?? "."}` }))));
         if (type !== "directory")
           return yield* Effect.fail(new ToolFailure({ message: `Search path is not a directory: ${searchPath ?? "."}` }));
         const root = target.absolute;
-        const limit = input.limit ?? exports_filesystem.DEFAULT_SEARCH_LIMIT;
+        const limit = input.limit ?? DEFAULT_SEARCH_LIMIT2;
         const entries = yield* ripgrep.glob({
           cwd: root,
           pattern: input.pattern,
           hidden: input.hidden,
           limit: limit + 1
         }).pipe(Effect.timeoutOrElse({
-          duration: exports_filesystem.DEFAULT_SEARCH_TIMEOUT_MS,
+          duration: DEFAULT_SEARCH_TIMEOUT_MS2,
           orElse: () => Effect.fail(new ToolFailure({
-            message: `Search timed out after ${exports_filesystem.DEFAULT_SEARCH_TIMEOUT_MS / 1000} seconds. Consider using a more specific path or pattern.`
+            message: `Search timed out after ${DEFAULT_SEARCH_TIMEOUT_MS2 / 1000} seconds. Consider using a more specific path or pattern.`
           }))
-        }), Effect.map((result) => result.map((entry) => exports_filesystem.Entry.make({
+        }), Effect.map((result) => result.map((entry) => Entry4.make({
           ...entry,
-          path: RelativePath.make(path.relative(location.directory, path.resolve(root, entry.path)))
+          path: RelativePath2.make(path.relative(location.directory, path.resolve(root, entry.path)))
         }))));
         return { entries: entries.slice(0, limit), truncated: entries.length > limit };
       }).pipe(Effect.map((result) => ({
         output: result.entries,
-        content: toModelContent(result.entries.map((entry) => ({ ...entry, path: path.resolve(location.directory, entry.path) })), result.truncated),
+        content: toModelContent3(result.entries.map((entry) => ({ ...entry, path: path.resolve(location.directory, entry.path) })), result.truncated),
         metadata: { count: result.entries.length, truncated: result.truncated }
       })), Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to find files matching ${input.pattern}`, error })))
     })).pipe(Effect.orDie);
   })
 };
 
-export { name, Input, Output, toModelContent, Plugin, exports_glob };
+export { name8, Input8, Output5, toModelContent3, Plugin9, exports_glob };

package/dist/chunks/{instance-1yj4rbe8.js → kv-nde3t6pb.js}

@@ -1,26 +1,29 @@
 import {
-  exports_kv
-} from "./instance-qtvzgpey.js";
+  ephemeral2,
+  Service79,
+  node83
+} from "./kv-9j3fyze8.js";
 import {
-  exports_bus
-} from "./instance-3dwd52hd.js";
+  Service68,
+  node72
+} from "./kv-keptat7v.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/wellknown.ts
 var exports_wellknown = {};
 __export(exports_wellknown, {
-  Auth: () => Auth,
-  Config: () => Config,
-  Event: () => Event,
-  Manifest: () => Manifest,
-  RemoteConfig: () => RemoteConfig,
-  Service: () => Service,
+  Auth: () => Auth2,
+  Config: () => Config2,
+  Event: () => Event15,
+  Manifest: () => Manifest2,
+  RemoteConfig: () => RemoteConfig2,
+  Service: () => Service67,
   WellKnown: () => exports_wellknown,
-  inspect: () => inspect,
-  node: () => node,
-  resolve: () => resolve
+  inspect: () => inspect2,
+  node: () => node71,
+  resolve: () => resolve3
 });
 import { Integration } from "@opencode-ai/schema/integration";
 import { Context, Effect, Layer, Ref, Schema, Semaphore } from "effect";
@@ -28,33 +31,33 @@ import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstab
 import { isDeepStrictEqual } from "node:util";
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
 import { httpClient } from "@opencode-ai/util/effect/app-node-platform";
-var Auth = Schema.Struct({
+var Auth2 = Schema.Struct({
   command: Schema.Array(Schema.String),
   env: Schema.String
 }).annotate({ identifier: "WellKnown.Auth" });
-var RemoteConfig = Schema.Struct({
+var RemoteConfig2 = Schema.Struct({
   url: Schema.String,
   headers: Schema.optional(Schema.Record(Schema.String, Schema.String))
 }).annotate({ identifier: "WellKnown.RemoteConfig" });
-var Config = Schema.Record(Schema.String, Schema.Json).annotate({ identifier: "WellKnown.Config" });
-var Manifest = Schema.Struct({
-  auth: Schema.optional(Auth),
-  config: Schema.optional(Schema.NullOr(Config)),
-  remote_config: Schema.optional(RemoteConfig)
+var Config2 = Schema.Record(Schema.String, Schema.Json).annotate({ identifier: "WellKnown.Config" });
+var Manifest2 = Schema.Struct({
+  auth: Schema.optional(Auth2),
+  config: Schema.optional(Schema.NullOr(Config2)),
+  remote_config: Schema.optional(RemoteConfig2)
 }).annotate({ identifier: "WellKnown.Manifest" });
 
-class Service extends Context.Service()("@opencode/WellKnown") {
+class Service67 extends Context.Service()("@opencode/WellKnown") {
 }
-var Event = {
-  Updated: exports_bus.ephemeral({ type: "wellknown.updated", schema: {} })
+var Event15 = {
+  Updated: ephemeral2({ type: "wellknown.updated", schema: {} })
 };
-var inspect = Effect.fn("WellKnown.inspect")(function* (origin) {
+var inspect2 = Effect.fn("WellKnown.inspect")(function* (origin) {
   const url = `${origin.replace(/\/+$/, "")}/.well-known/opencode`;
   const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
-  return yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson)).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Manifest)), Effect.mapError((cause) => new Error(`Failed to load wellknown manifest from ${url}`, { cause })));
+  return yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson)).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Manifest2)), Effect.mapError((cause) => new Error(`Failed to load wellknown manifest from ${url}`, { cause })));
 });
-var resolve = Effect.fn("WellKnown.resolve")(function* (input) {
-  const manifest = yield* inspect(input.origin);
+var resolve3 = Effect.fn("WellKnown.resolve")(function* (input) {
+  const manifest = yield* inspect2(input.origin);
   return yield* resolveEntry({ origin: input.origin, integrationID: Integration.ID.make(input.origin.replace(/\/+$/, "")), manifest }, input.variables ?? {});
 });
 var resolveEntry = Effect.fnUntraced(function* (entry, variables) {
@@ -65,21 +68,21 @@ var resolveEntry = Effect.fnUntraced(function* (entry, variables) {
   const url = substitute(entry.manifest.remote_config.url);
   const headers = Object.fromEntries(Object.entries(entry.manifest.remote_config.headers ?? {}).map(([key, value]) => [key, substitute(value)]));
   const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
-  const remote = yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson, HttpClientRequest.setHeaders(headers))).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Config)), Effect.mapError((cause) => new Error(`Failed to load wellknown remote config from ${url}`, { cause })));
-  if (Schema.is(Config)(remote.config))
+  const remote = yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson, HttpClientRequest.setHeaders(headers))).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Config2)), Effect.mapError((cause) => new Error(`Failed to load wellknown remote config from ${url}`, { cause })));
+  if (Schema.is(Config2)(remote.config))
     return [...configs, remote.config];
   return [...configs, remote];
 });
 var sourcesKey = "wellknown:sources";
 var Sources = Schema.Array(Schema.String);
-var layer = Layer.effect(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service67, Effect.gen(function* () {
   const http = yield* HttpClient.HttpClient;
-  const kv = yield* exports_kv.Service;
-  const bus = yield* exports_bus.Service;
+  const kv = yield* Service68;
+  const bus = yield* Service79;
   const cache = yield* Ref.make(new Map);
   const lock = Semaphore.makeUnsafe(1);
   const loadEntry = Effect.fn("WellKnown.loadEntry")(function* (origin) {
-    const manifest = yield* inspect(origin).pipe(Effect.provideService(HttpClient.HttpClient, http));
+    const manifest = yield* inspect2(origin).pipe(Effect.provideService(HttpClient.HttpClient, http));
     return { origin, integrationID: Integration.ID.make(origin), manifest };
   });
   const load = Effect.fn("WellKnown.load")(function* () {
@@ -106,10 +109,10 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     if (!changed)
       return false;
     yield* Ref.set(cache, next);
-    yield* bus.publish(Event.Updated, {});
+    yield* bus.publish(Event15.Updated, {});
     return true;
   }, (effect) => lock.withPermit(effect));
-  return Service.of({
+  return Service67.of({
     entries: load,
     snapshot: () => Array.from(Ref.getUnsafe(cache).values()),
     refresh,
@@ -122,7 +125,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       const origins = Schema.is(Sources)(sources) ? sources : [];
       yield* kv.set(sourcesKey, Array.from(new Set([...origins, origin])));
       yield* Ref.update(cache, (current) => new Map(current).set(origin, entry));
-      yield* bus.publish(Event.Updated, {});
+      yield* bus.publish(Event15.Updated, {});
       return entry;
     }, (effect, _value) => lock.withPermit(effect)),
     remove: Effect.fn("WellKnown.remove")(function* (value) {
@@ -135,11 +138,11 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         next.delete(origin);
         return next;
       });
-      yield* bus.publish(Event.Updated, {});
+      yield* bus.publish(Event15.Updated, {});
     }, (effect, _value) => lock.withPermit(effect)),
     resolve: Effect.fn("WellKnown.resolveEntry")((entry, variables) => resolveEntry(entry, variables).pipe(Effect.provideService(HttpClient.HttpClient, http)))
   });
 }));
-var node = makeGlobalNode({ service: Service, layer, deps: [httpClient, exports_kv.node, exports_bus.node] });
+var node71 = makeGlobalNode({ service: Service67, layer, deps: [httpClient, node72, node83] });
 
-export { Auth, RemoteConfig, Config, Manifest, Service, Event, inspect, resolve, node, exports_wellknown };
+export { Auth2, RemoteConfig2, Config2, Manifest2, Service67, Event15, inspect2, resolve3, node71, exports_wellknown };