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

package/dist/chunks/{schema-4hbpra3r.js → event-logger-2h6s9956.js}

@@ -1,80 +1,84 @@
 import {
-  exports_skill
-} from "./schema-mw1qz6py.js";
+  Service80
+} from "./event-logger-4vtp7hga.js";
 import {
-  exports_revert
-} from "./schema-ce4hyqkb.js";
+  Service79
+} from "./event-logger-jbmjz4v3.js";
 import {
-  exports_shell
-} from "./schema-cdy2ypjf.js";
+  Service33
+} from "./event-logger-yhtqjkzd.js";
 import {
-  exports_prompt
-} from "./schema-e2jftvbf.js";
+  userNotification2
+} from "./event-logger-fxbjtjnd.js";
 import {
-  exports_execution
-} from "./schema-r9srg7kj.js";
+  SessionMessage2
+} from "./event-logger-982e01ww.js";
 import {
-  exports_inbox
-} from "./schema-3rcd4hwd.js";
+  NotFoundError9,
+  MessageNotFoundError2,
+  MessageNotAssistantError2,
+  MessageIncompleteError2,
+  MessageToolIncompleteError2,
+  PromptConflictError2,
+  SyntheticConflictError2,
+  CompactionConflictError2,
+  BusyError2,
+  InboxConflictError2
+} from "./event-logger-n6wnzfnt.js";
 import {
-  exports_service
-} from "./schema-6bxzghb6.js";
+  SessionEvent2
+} from "./event-logger-mntxs535.js";
 import {
-  exports_store
-} from "./schema-a4wk7wxx.js";
+  Service72
+} from "./event-logger-xf2wyvfy.js";
 import {
-  BusyError,
-  CompactionConflictError,
-  InboxConflictError,
-  MessageIncompleteError,
-  MessageNotAssistantError,
-  MessageNotFoundError,
-  MessageToolIncompleteError,
-  NotFoundError,
-  PromptConflictError,
-  SyntheticConflictError
-} from "./schema-2sqw2jjm.js";
+  Delivery2,
+  SyntheticPayload2,
+  Service29
+} from "./event-logger-aymbgepw.js";
 import {
-  SessionMessage
-} from "./schema-8rpfd2h6.js";
+  Service27
+} from "./event-logger-65rxya3j.js";
 import {
-  SessionEvent
-} from "./schema-a83yvq99.js";
+  prepare2
+} from "./event-logger-ydk5gqry.js";
 import {
-  exports_result
-} from "./schema-5y5kqjze.js";
+  stage2,
+  clear2,
+  commit2
+} from "./event-logger-4w2mg71f.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  start2
+} from "./event-logger-rkkn0pd8.js";
 import {
-  exports_database
-} from "./schema-8scqw7rh.js";
+  get4
+} from "./event-logger-8ct07e69.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/session/session.ts
-var exports_session = {};
-__export(exports_session, {
-  Session: () => exports_session,
-  make: () => make
+var exports_session2 = {};
+__export(exports_session2, {
+  Session: () => exports_session2,
+  make: () => make12
 });
 import { DateTime, Effect, Fiber, Schema, Scope } from "effect";
 import { Event } from "@opencode-ai/schema/event";
 import { FSUtil } from "@opencode-ai/util/fs-util";
-var make = Effect.fn("Session.make")(function* () {
-  const bus = yield* exports_bus.Service;
-  const database = yield* exports_database.Service;
-  const store = yield* exports_store.Service;
-  const instances = yield* exports_service.Service;
-  const execution = yield* exports_execution.Service;
-  const admission = yield* exports_inbox.Service;
+var make12 = Effect.fn("Session.make")(function* () {
+  const bus = yield* Service79;
+  const database = yield* Service80;
+  const store = yield* Service72;
+  const instances = yield* Service33;
+  const execution = yield* Service27;
+  const admission = yield* Service29;
   const fs = yield* FSUtil.Service;
   const scope = yield* Scope.Scope;
   const get = Effect.fn("Session.get")(function* (sessionID) {
     const session = yield* store.get(sessionID);
     if (!session)
-      return yield* new NotFoundError({ sessionID });
+      return yield* new NotFoundError9({ sessionID });
     return session;
   });
   const message = Effect.fn("Session.message")(function* (sessionID, messageID) {
@@ -85,48 +89,48 @@ var make = Effect.fn("Session.make")(function* () {
     const ref = { sessionID, messageID: input.messageID };
     yield* get(sessionID);
     if (yield* execution.isActive(sessionID))
-      return yield* new BusyError({ sessionID });
+      return yield* new BusyError2({ sessionID });
     const current = yield* message(sessionID, input.messageID);
     if (!current)
-      return yield* new MessageNotFoundError(ref);
+      return yield* new MessageNotFoundError2(ref);
     if (current.type !== "assistant")
-      return yield* new MessageNotAssistantError(ref);
+      return yield* new MessageNotAssistantError2(ref);
     if (!current.time.completed)
-      return yield* new MessageIncompleteError(ref);
+      return yield* new MessageIncompleteError2(ref);
     if (input.content.some(isUnfinishedTool))
-      return yield* new MessageToolIncompleteError(ref);
-    yield* bus.publish(SessionEvent.MessageContentUpdated, {
+      return yield* new MessageToolIncompleteError2(ref);
+    yield* bus.publish(SessionEvent2.MessageContentUpdated, {
       ...ref,
-      content: Schema.encodeSync(Schema.Array(SessionMessage.AssistantContent))(input.content)
+      content: Schema.encodeSync(Schema.Array(SessionMessage2.AssistantContent))(input.content)
     });
     const updated = yield* message(sessionID, input.messageID);
     if (updated?.type !== "assistant")
-      return yield* new MessageNotFoundError(ref);
+      return yield* new MessageNotFoundError2(ref);
     return updated;
   });
   const view = Effect.fn("Session.view")(function* (sessionID, input) {
     const session = yield* get(sessionID);
     if (session.time.idle === undefined || input.idle > DateTime.toEpochMillis(session.time.idle) || session.time.viewed !== undefined && DateTime.toEpochMillis(session.time.viewed) >= input.idle)
       return;
-    yield* bus.publish(SessionEvent.Viewed, { sessionID, idle: input.idle });
+    yield* bus.publish(SessionEvent2.Viewed, { sessionID, idle: input.idle });
   });
   const rename = Effect.fn("Session.rename")(function* (sessionID, input) {
     yield* get(sessionID);
-    yield* bus.publish(SessionEvent.Renamed, { sessionID, title: input.title });
+    yield* bus.publish(SessionEvent2.Renamed, { sessionID, title: input.title });
   });
   const switchAgent = Effect.fn("Session.switchAgent")(function* (sessionID, input) {
     const session = yield* get(sessionID);
-    yield* bus.publish(SessionEvent.AgentSelected, { sessionID, agent: input.agent, previous: session.agent });
+    yield* bus.publish(SessionEvent2.AgentSelected, { sessionID, agent: input.agent, previous: session.agent });
   });
   const switchModel = Effect.fn("Session.switchModel")(function* (sessionID, input) {
     const session = yield* get(sessionID);
     if (session.model?.providerID === input.model.providerID && session.model.id === input.model.id && (session.model.variant ?? "default") === (input.model.variant ?? "default"))
       return;
-    yield* bus.publish(SessionEvent.ModelSelected, { sessionID, model: input.model, previous: session.model });
+    yield* bus.publish(SessionEvent2.ModelSelected, { sessionID, model: input.model, previous: session.model });
   });
   const mutatePending = (sessionID, inboxID, mutation) => mutation({ sessionID, id: inboxID }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => Effect.gen(function* () {
     yield* get(sessionID);
-    return yield* new InboxConflictError({ sessionID, inboxID });
+    return yield* new InboxConflictError2({ sessionID, inboxID });
   })));
   const inbox = Effect.fn("Session.inbox")(function* (sessionID) {
     yield* get(sessionID);
@@ -140,7 +144,7 @@ var make = Effect.fn("Session.make")(function* () {
   const queueInbox = Effect.fn("Session.queueInbox")((sessionID, inboxID) => mutatePending(sessionID, inboxID, admission.queue), Effect.uninterruptible);
   const prompt = Effect.fn("Session.prompt")((sessionID, input) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
     const session = yield* get(sessionID);
-    const messageID = input.id ?? SessionMessage.ID.create();
+    const messageID = input.id ?? SessionMessage2.ID.create();
     const admitted = yield* Effect.gen(function* () {
       const existing = yield* admission.reconcile({
         id: messageID,
@@ -150,15 +154,15 @@ var make = Effect.fn("Session.make")(function* () {
       });
       if (existing)
         return existing;
-      const item = yield* restore(exports_prompt.prepare({ session, messageID, input }).pipe(Effect.provideService(exports_service.Service, instances), Effect.provideService(FSUtil.Service, fs)));
+      const item = yield* restore(prepare2({ session, messageID, input }).pipe(Effect.provideService(Service33, instances), Effect.provideService(FSUtil.Service, fs)));
       if (session.revert)
-        yield* exports_revert.commit(bus, session);
+        yield* commit2(bus, session);
       return yield* admission.admit({
         id: messageID,
         sessionID: session.id,
         item
       });
-    }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => new PromptConflictError({ sessionID, messageID })));
+    }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => new PromptConflictError2({ sessionID, messageID })));
     if (input.resume !== false)
       yield* execution.wake(sessionID);
     return admitted;
@@ -166,7 +170,7 @@ var make = Effect.fn("Session.make")(function* () {
   const shell = Effect.fn("Session.shell")(function* (sessionID, input) {
     const session = yield* get(sessionID);
     const running = yield* Effect.gen(function* () {
-      const started = yield* exports_shell.start({ session, command: input.command }).pipe(Effect.provideService(exports_service.Service, instances), Effect.tapError((error) => synthetic(sessionID, {
+      const started = yield* start2({ session, command: input.command }).pipe(Effect.provideService(Service33, instances), Effect.tapError((error) => synthetic(sessionID, {
         text: `User shell command failed to start:
 ${input.command}
 
@@ -175,19 +179,19 @@ ${error.message}`,
         metadata: { source: "shell", state: "error" },
         resume: false
       })), Effect.orDie);
-      yield* bus.publish(SessionEvent.Shell.Started, {
+      yield* bus.publish(SessionEvent2.Shell.Started, {
         sessionID,
         shell: started.info
       }, { id: input.id });
       const terminal = yield* started.result;
       const preview = yield* started.output;
-      yield* bus.publish(SessionEvent.Shell.Ended, {
+      yield* bus.publish(SessionEvent2.Shell.Ended, {
         sessionID,
         shell: terminal.info,
         output: preview
       });
       yield* synthetic(sessionID, {
-        ...exports_result.userNotification(terminal),
+        ...userNotification2(terminal),
         resume: false
       }).pipe(Effect.catchTag("Session.NotFoundError", () => Effect.void), Effect.orDie);
     }).pipe(Effect.forkIn(scope, { startImmediately: true }));
@@ -195,12 +199,12 @@ ${error.message}`,
   });
   const skill = Effect.fn("Session.skill")(function* (sessionID, input) {
     const session = yield* get(sessionID);
-    const skill2 = yield* exports_skill.get({ session, skill: input.skill }).pipe(Effect.provideService(exports_service.Service, instances));
-    yield* bus.publish(SessionEvent.Skill.Activated, {
+    const skill = yield* get4({ session, skill: input.skill }).pipe(Effect.provideService(Service33, instances));
+    yield* bus.publish(SessionEvent2.Skill.Activated, {
       sessionID,
-      id: skill2.id,
-      name: skill2.name,
-      text: skill2.content
+      id: skill.id,
+      name: skill.name,
+      text: skill.content
     }, { id: input.id ? Event.ID.make(input.id.replace(/^msg_/, "evt_")) : undefined });
     if (input.resume !== false)
       yield* execution.resume(sessionID).pipe(Effect.ignore, Effect.forkIn(scope, { startImmediately: true }), Effect.asVoid);
@@ -208,13 +212,13 @@ ${error.message}`,
   const compact = Effect.fn("Session.compact")(function* (sessionID, input) {
     const session = yield* get(sessionID);
     if (session.revert)
-      yield* exports_revert.commit(bus, session);
-    const inputID = input.id ?? SessionMessage.ID.create();
+      yield* commit2(bus, session);
+    const inputID = input.id ?? SessionMessage2.ID.create();
     const admitted = yield* admission.admitCompaction({
       id: inputID,
       sessionID,
       delivery: input.delivery ?? "steer"
-    }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => new CompactionConflictError({ sessionID, inputID })));
+    }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => new CompactionConflictError2({ sessionID, inputID })));
     yield* execution.wake(sessionID);
     return admitted;
   });
@@ -228,21 +232,21 @@ ${error.message}`,
   });
   const synthetic = Effect.fn("Session.synthetic")((sessionID, input) => Effect.uninterruptible(Effect.gen(function* () {
     yield* get(sessionID);
-    const inputID = input.id ?? SessionMessage.ID.create();
+    const inputID = input.id ?? SessionMessage2.ID.create();
     const admittedInput = {
       type: "synthetic",
-      payload: exports_inbox.SyntheticPayload.make({
+      payload: SyntheticPayload2.make({
         text: input.text,
         description: input.description,
         metadata: input.metadata
       }),
-      delivery: exports_inbox.Delivery.make(input.delivery ?? "steer")
+      delivery: Delivery2.make(input.delivery ?? "steer")
     };
     const admitted = yield* admission.admit({
       id: inputID,
       sessionID,
       item: admittedInput
-    }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => new SyntheticConflictError({ sessionID, inputID })));
+    }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => new SyntheticConflictError2({ sessionID, inputID })));
     if (input.resume !== false && !(yield* get(sessionID)).revert)
       yield* execution.wake(sessionID);
     return admitted;
@@ -251,21 +255,21 @@ ${error.message}`,
   const stage = Effect.fn("Session.revert.stage")(function* (sessionID, input) {
     const session = yield* get(sessionID);
     if (yield* execution.isActive(sessionID))
-      return yield* new BusyError({ sessionID });
-    return yield* exports_revert.stage({ session, messageID: input.messageID, files: input.files }).pipe(Effect.provideService(exports_service.Service, instances), Effect.provideService(exports_database.Service, database), Effect.provideService(exports_bus.Service, bus));
+      return yield* new BusyError2({ sessionID });
+    return yield* stage2({ session, messageID: input.messageID, files: input.files }).pipe(Effect.provideService(Service33, instances), Effect.provideService(Service80, database), Effect.provideService(Service79, bus));
   });
   const clear = Effect.fn("Session.revert.clear")(function* (sessionID) {
     const session = yield* get(sessionID);
     if (yield* execution.isActive(sessionID))
-      return yield* new BusyError({ sessionID });
-    yield* exports_revert.clear(session).pipe(Effect.provideService(exports_service.Service, instances), Effect.provideService(exports_bus.Service, bus));
+      return yield* new BusyError2({ sessionID });
+    yield* clear2(session).pipe(Effect.provideService(Service33, instances), Effect.provideService(Service79, bus));
     return yield* execution.wake(sessionID);
   });
   const commit = Effect.fn("Session.revert.commit")(function* (sessionID) {
     const session = yield* get(sessionID);
     if (yield* execution.isActive(sessionID))
-      return yield* new BusyError({ sessionID });
-    return yield* exports_revert.commit(bus, session);
+      return yield* new BusyError2({ sessionID });
+    return yield* commit2(bus, session);
   });
   const revert = { stage, clear, commit };
   const operations = {
@@ -291,51 +295,51 @@ ${error.message}`,
     revert
   };
   const forSession = (sessionID) => {
-    const get2 = operations.get.bind(undefined, sessionID);
-    const message2 = operations.message.bind(undefined, sessionID);
-    const updateMessage2 = operations.updateMessage.bind(undefined, sessionID);
-    const view2 = operations.view.bind(undefined, sessionID);
-    const rename2 = operations.rename.bind(undefined, sessionID);
-    const switchAgent2 = operations.switchAgent.bind(undefined, sessionID);
-    const switchModel2 = operations.switchModel.bind(undefined, sessionID);
-    const inbox2 = operations.inbox.bind(undefined, sessionID);
-    const prompt2 = operations.prompt.bind(undefined, sessionID);
-    const synthetic2 = operations.synthetic.bind(undefined, sessionID);
-    const shell2 = operations.shell.bind(undefined, sessionID);
-    const skill2 = operations.skill.bind(undefined, sessionID);
-    const compact2 = operations.compact.bind(undefined, sessionID);
-    const wait2 = operations.wait.bind(undefined, sessionID);
-    const resume2 = operations.resume.bind(undefined, sessionID);
-    const interrupt2 = operations.interrupt.bind(undefined, sessionID);
-    const cancelInbox2 = operations.cancelInbox.bind(undefined, sessionID);
-    const steerInbox2 = operations.steerInbox.bind(undefined, sessionID);
-    const queueInbox2 = operations.queueInbox.bind(undefined, sessionID);
-    const stage2 = operations.revert.stage.bind(undefined, sessionID);
-    const clear2 = operations.revert.clear.bind(undefined, sessionID);
-    const commit2 = operations.revert.commit.bind(undefined, sessionID);
-    const revert2 = { stage: stage2, clear: clear2, commit: commit2 };
+    const get = operations.get.bind(undefined, sessionID);
+    const message = operations.message.bind(undefined, sessionID);
+    const updateMessage = operations.updateMessage.bind(undefined, sessionID);
+    const view = operations.view.bind(undefined, sessionID);
+    const rename = operations.rename.bind(undefined, sessionID);
+    const switchAgent = operations.switchAgent.bind(undefined, sessionID);
+    const switchModel = operations.switchModel.bind(undefined, sessionID);
+    const inbox = operations.inbox.bind(undefined, sessionID);
+    const prompt = operations.prompt.bind(undefined, sessionID);
+    const synthetic = operations.synthetic.bind(undefined, sessionID);
+    const shell = operations.shell.bind(undefined, sessionID);
+    const skill = operations.skill.bind(undefined, sessionID);
+    const compact = operations.compact.bind(undefined, sessionID);
+    const wait = operations.wait.bind(undefined, sessionID);
+    const resume = operations.resume.bind(undefined, sessionID);
+    const interrupt = operations.interrupt.bind(undefined, sessionID);
+    const cancelInbox = operations.cancelInbox.bind(undefined, sessionID);
+    const steerInbox = operations.steerInbox.bind(undefined, sessionID);
+    const queueInbox = operations.queueInbox.bind(undefined, sessionID);
+    const stage = operations.revert.stage.bind(undefined, sessionID);
+    const clear = operations.revert.clear.bind(undefined, sessionID);
+    const commit = operations.revert.commit.bind(undefined, sessionID);
+    const revert = { stage, clear, commit };
     return {
       id: sessionID,
-      get: get2,
-      message: message2,
-      updateMessage: updateMessage2,
-      view: view2,
-      rename: rename2,
-      switchAgent: switchAgent2,
-      switchModel: switchModel2,
-      inbox: inbox2,
-      prompt: prompt2,
-      synthetic: synthetic2,
-      shell: shell2,
-      skill: skill2,
-      compact: compact2,
-      wait: wait2,
-      resume: resume2,
-      interrupt: interrupt2,
-      cancelInbox: cancelInbox2,
-      steerInbox: steerInbox2,
-      queueInbox: queueInbox2,
-      revert: revert2
+      get,
+      message,
+      updateMessage,
+      view,
+      rename,
+      switchAgent,
+      switchModel,
+      inbox,
+      prompt,
+      synthetic,
+      shell,
+      skill,
+      compact,
+      wait,
+      resume,
+      interrupt,
+      cancelInbox,
+      steerInbox,
+      queueInbox,
+      revert
     };
   };
   return { forSession };
@@ -344,4 +348,4 @@ function isUnfinishedTool(content) {
   return content.type === "tool" && (content.state.status === "streaming" || content.state.status === "running");
 }
 
-export { make, exports_session };
+export { make12, exports_session2 };

package/dist/chunks/{schema-k7hkdbw5.js → event-logger-2ht70gj7.js}

@@ -1,12 +1,9 @@
 import {
-  createProviderPlugin
-} from "./schema-0zz82cjq.js";
-import {
-  __require
-} from "./schema-vpjkya7h.js";
+  createProviderPlugin2
+} from "./event-logger-se0s1eqw.js";
 
 // src/plugin/provider/venice.ts
-var VenicePlugin = createProviderPlugin({
+var VenicePlugin2 = createProviderPlugin2({
   id: "opencode.provider.venice",
   package: "venice-ai-sdk-provider",
   load: async (options) => {
@@ -15,4 +12,4 @@ var VenicePlugin = createProviderPlugin({
   }
 });
 
-export { VenicePlugin };
+export { VenicePlugin2 };

package/dist/chunks/{schema-r7a2r1m6.js → event-logger-2jqmte8w.js}

@@ -1,16 +1,16 @@
 import {
-  exports_promise
-} from "./schema-hy5n5jcn.js";
+  fromPromise2
+} from "./event-logger-b9wsbatv.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/plugin/module.ts
 var exports_module = {};
 __export(exports_module, {
-  LoadError: () => LoadError,
+  LoadError: () => LoadError2,
   PluginModule: () => exports_module,
-  load: () => load
+  load: () => load2
 });
 import { Host } from "@opencode-ai/plugin/host";
 import { Npm } from "@opencode-ai/util/npm";
@@ -31,12 +31,12 @@ var Module = Schema.Struct({
   ])
 });
 
-class LoadError extends Schema.TaggedError()("PluginModule.LoadError", {
+class LoadError2 extends Schema.TaggedError()("PluginModule.LoadError", {
   message: Schema.String,
   cause: Schema.optional(Schema.Defect())
 }) {
 }
-var load = Effect.fn("PluginModule.load")(function* (operation, options) {
+var load2 = Effect.fn("PluginModule.load")(function* (operation, options) {
   const local = path.isAbsolute(operation.target);
   const npm = yield* Npm.Service;
   const installed = local ? undefined : options?.install === false ? yield* npm.resolve(operation.target) : yield* npm.add(operation.target);
@@ -45,16 +45,16 @@ var load = Effect.fn("PluginModule.load")(function* (operation, options) {
   if (!local && options?.install === false && !entrypoint)
     return { pending: true };
   if (!entrypoint)
-    return yield* new LoadError({ message: `Plugin entrypoint not found: ${operation.target}` });
+    return yield* new LoadError2({ message: `Plugin entrypoint not found: ${operation.target}` });
   const target = typeof Bun !== "undefined" ? fileURLToPath(entrypoint).replaceAll("\\", "/") : entrypoint;
   const source = operation.mtime === undefined ? entrypoint : `${target}?mtime=${operation.mtime}`;
   yield* Effect.log({ msg: "loading plugin", id: operation.target, entrypoint: source });
   const mod = yield* Effect.promise(() => Host.load(source));
-  const value = (yield* Schema.decodeUnknownEffect(Module)(mod).pipe(Effect.mapError((cause) => new LoadError({
+  const value = (yield* Schema.decodeUnknownEffect(Module)(mod).pipe(Effect.mapError((cause) => new LoadError2({
     message: "Plugin must export a default definition with an id and an effect or setup function.",
     cause
   })))).default;
-  const plugin = "effect" in value ? value : exports_promise.fromPromise(value);
+  const plugin = "effect" in value ? value : fromPromise2(value);
   return {
     id: plugin.id,
     features: {
@@ -71,4 +71,4 @@ var load = Effect.fn("PluginModule.load")(function* (operation, options) {
   };
 });
 
-export { LoadError, load, exports_module };
+export { LoadError2, load2, exports_module };

package/dist/chunks/event-logger-2k8khapm.js

@@ -0,0 +1,16 @@
+import {
+  __export
+} from "./event-logger-9rqn6x4v.js";
+
+// src/v1/config/plugin.ts
+var exports_plugin3 = {};
+__export(exports_plugin3, {
+  ConfigPluginV1: () => exports_plugin3,
+  Options: () => Options8,
+  Spec: () => Spec2
+});
+import { Schema } from "effect";
+var Options8 = Schema.Record(Schema.String, Schema.Unknown);
+var Spec2 = Schema.Union([Schema.String, Schema.mutable(Schema.Tuple([Schema.String, Options8]))]);
+
+export { Options8, Spec2, exports_plugin3 };