@opencode-ai/core 0.0.0-dev-19092 → 0.0.0-dev-19094

package/dist/chunks/{integration-nh84sznz.js → command-1hzpknhe.js}

@@ -1,70 +1,76 @@
 import {
-  exports_runner
-} from "./integration-0rz7yd7x.js";
+  Service80,
+  node84
+} from "./command-mh85gtv1.js";
 import {
-  exports_run_coordinator
-} from "./integration-f8wvq04h.js";
+  Service79,
+  node83
+} from "./command-pdae5shs.js";
 import {
-  exports_inbox
-} from "./integration-d9nzfyee.js";
+  Service47,
+  node49
+} from "./command-8f30jcen.js";
 import {
-  toSessionError
-} from "./integration-xkdb1c6k.js";
+  Service33,
+  node35
+} from "./command-y092mk2a.js";
 import {
-  exports_service
-} from "./integration-6bxzghb6.js";
+  SessionEvent2
+} from "./command-mntxs535.js";
 import {
-  exports_job
-} from "./integration-bymgjy4k.js";
+  make14
+} from "./command-djtdz80w.js";
 import {
-  exports_store
-} from "./integration-jwp0b78z.js";
+  DrainResult2,
+  Service29
+} from "./command-ag4rn41e.js";
 import {
-  UserInterruptedError
-} from "./integration-2sqw2jjm.js";
+  UserInterruptedError2
+} from "./command-c28brx2k.js";
 import {
-  SessionEvent
-} from "./integration-a83yvq99.js";
+  Service44,
+  node46
+} from "./command-ha4v9y42.js";
 import {
-  exports_bus
-} from "./integration-hf9h67zk.js";
+  toSessionError2
+} from "./command-vedqaezr.js";
 import {
-  exports_database
-} from "./integration-3dyzk5zr.js";
+  nextPromotable2
+} from "./command-32m8x2r5.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/session/execution.ts
 var exports_execution = {};
 __export(exports_execution, {
-  Service: () => Service,
+  Service: () => Service28,
   SessionExecution: () => exports_execution,
-  layer: () => layer,
-  node: () => node,
-  noopLayer: () => noopLayer,
-  terminal: () => terminal
+  layer: () => layer13,
+  node: () => node32,
+  noopLayer: () => noopLayer2,
+  terminal: () => terminal2
 });
 import { Cause, Context, Effect, Exit, Layer } from "effect";
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
-class Service extends Context.Service()("@opencode/SessionExecution") {
+class Service28 extends Context.Service()("@opencode/SessionExecution") {
 }
-function terminal(exit, reason) {
+function terminal2(exit, reason) {
   if (Exit.isSuccess(exit))
     return { type: "succeeded" };
   if (Cause.hasInterrupts(exit.cause))
     return { type: "interrupted", reason: reason ?? "shutdown" };
   const failure = Cause.squash(exit.cause);
-  if (failure instanceof UserInterruptedError)
+  if (failure instanceof UserInterruptedError2)
     return { type: "interrupted", reason: "user" };
-  return { type: "failed", error: toSessionError(failure) };
+  return { type: "failed", error: toSessionError2(failure) };
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const store = yield* exports_store.Service;
-  const instances = yield* exports_service.Service;
-  const bus = yield* exports_bus.Service;
-  const jobs = yield* exports_job.Service;
-  const db = (yield* exports_database.Service).db;
+var layer13 = Layer.effect(Service28, Effect.gen(function* () {
+  const store = yield* Service44;
+  const instances = yield* Service33;
+  const bus = yield* Service79;
+  const jobs = yield* Service47;
+  const db = (yield* Service80).db;
   const reportLifecycle = (sessionID, effect) => effect.pipe(Effect.tapCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logError("Failed to publish Session execution lifecycle", cause).pipe(Effect.annotateLogs({ sessionID }))), Effect.asVoid);
   const claimOnCommit = (sessionID) => ({
     commit: () => store.claim(sessionID)
@@ -76,41 +82,41 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const session = yield* store.get(sessionID);
     if (!session)
       return yield* Effect.die(new Error(`Session not found: ${sessionID}`));
-    const result = yield* exports_runner.Service.use((runner) => runner.drain({ sessionID, force, continuation, promotable })).pipe(instances.provide(session), Effect.tapCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logError("Failed to drain Session", cause).pipe(Effect.annotateLogs({ sessionID }))));
-    return yield* exports_runner.DrainResult.$match(result, {
+    const result = yield* Service29.use((runner) => runner.drain({ sessionID, force, continuation, promotable })).pipe(instances.provide(session), Effect.tapCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logError("Failed to drain Session", cause).pipe(Effect.annotateLogs({ sessionID }))));
+    return yield* DrainResult2.$match(result, {
       Complete: () => Effect.void,
-      Moved: (result2) => drain(sessionID, false, result2.continuation, promotable)
+      Moved: (result) => drain(sessionID, false, result.continuation, promotable)
     });
   });
-  const coordinator = yield* exports_run_coordinator.make({
-    started: (sessionID) => reportLifecycle(sessionID, bus.publish(SessionEvent.Execution.Started, { sessionID }, claimOnCommit(sessionID))),
+  const coordinator = yield* make14({
+    started: (sessionID) => reportLifecycle(sessionID, bus.publish(SessionEvent2.Execution.Started, { sessionID }, claimOnCommit(sessionID))),
     drain: (sessionID, force, promotable) => drain(sessionID, force, undefined, promotable),
     settled: (sessionID, exit, reason) => reportLifecycle(sessionID, Effect.gen(function* () {
-      const outcome = terminal(exit, reason);
+      const outcome = terminal2(exit, reason);
       if (outcome.type === "succeeded") {
-        yield* bus.publish(SessionEvent.Execution.Succeeded, { sessionID }, releaseOnCommit(sessionID));
+        yield* bus.publish(SessionEvent2.Execution.Succeeded, { sessionID }, releaseOnCommit(sessionID));
         return;
       }
       if (outcome.type === "interrupted") {
         if (outcome.reason === "user")
           yield* jobs.cancel(sessionID);
-        yield* bus.publish(SessionEvent.Execution.Interrupted, { sessionID, reason: outcome.reason }, outcome.reason === "shutdown" ? undefined : releaseOnCommit(sessionID));
+        yield* bus.publish(SessionEvent2.Execution.Interrupted, { sessionID, reason: outcome.reason }, outcome.reason === "shutdown" ? undefined : releaseOnCommit(sessionID));
         return;
       }
-      yield* bus.publish(SessionEvent.Execution.Failed, {
+      yield* bus.publish(SessionEvent2.Execution.Failed, {
         sessionID,
         error: outcome.error
       }, releaseOnCommit(sessionID));
     }))
   });
-  return Service.of({
+  return Service28.of({
     active: coordinator.active,
     isActive: coordinator.isActive,
     interrupt: (sessionID, options) => Effect.gen(function* () {
       const interrupted = yield* coordinator.interrupt(sessionID, "user");
       if (!options?.continue)
         return interrupted;
-      const next = yield* exports_inbox.nextPromotable(db, sessionID, "input");
+      const next = yield* nextPromotable2(db, sessionID, "input");
       if (next === undefined)
         return interrupted;
       if (next.delivery === "steer" || next.type === "compaction" || next.type === "move")
@@ -122,12 +128,12 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     awaitIdle: coordinator.awaitIdle
   });
 }));
-var node = makeGlobalNode({
-  service: Service,
-  layer,
-  deps: [exports_store.node, exports_service.node, exports_bus.node, exports_database.node, exports_job.node]
+var node32 = makeGlobalNode({
+  service: Service28,
+  layer: layer13,
+  deps: [node46, node35, node83, node84, node49]
 });
-var noopLayer = Layer.succeed(Service, Service.of({
+var noopLayer2 = Layer.succeed(Service28, Service28.of({
   active: Effect.succeed(new Set),
   isActive: () => Effect.succeed(false),
   resume: () => Effect.void,
@@ -136,4 +142,4 @@ var noopLayer = Layer.succeed(Service, Service.of({
   awaitIdle: () => Effect.void
 }));
 
-export { Service, terminal, layer, node, noopLayer, exports_execution };
+export { Service28, terminal2, layer13, node32, noopLayer2, exports_execution };

package/dist/chunks/command-1kg9ymc8.js

@@ -0,0 +1,6 @@
+// src/util/iife.ts
+function iife2(fn) {
+  return fn();
+}
+
+export { iife2 };

package/dist/chunks/{integration-2bqejk5j.js → command-1m2qxpbx.js}

@@ -1,34 +1,34 @@
 import {
-  DiffError
-} from "./integration-gbt1hr9b.js";
+  Service68
+} from "./command-4jcgzkct.js";
 import {
-  MAX_PATCH_BYTES,
-  MAX_TOTAL_PATCH_BYTES,
-  PATCH_CONTEXT_LINES,
-  chunksByFile,
-  emptyPatch
-} from "./integration-3chx3ng6.js";
+  PATCH_CONTEXT_LINES2,
+  MAX_PATCH_BYTES2,
+  MAX_TOTAL_PATCH_BYTES2,
+  emptyPatch2,
+  chunksByFile2
+} from "./command-tazgh4e4.js";
 import {
-  exports_location
-} from "./integration-gpa7n6yh.js";
+  DiffError2
+} from "./command-hv5tmyxa.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/plugin/vcs/git.ts
 var exports_git = {};
 __export(exports_git, {
-  Plugin: () => Plugin,
+  Plugin: () => Plugin5,
   VcsGitPlugin: () => exports_git
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect } from "effect";
 import { ChildProcess } from "effect/unstable/process";
 import { AppProcess } from "@opencode-ai/util/process";
-var Plugin = define({
+var Plugin5 = define({
   id: "opencode.vcs.git",
   effect: Effect.fn("VcsGitPlugin")(function* (ctx) {
-    const location = yield* exports_location.Service;
+    const location = yield* Service68;
     if (location.vcs?.type !== "git")
       return;
     const processes = yield* AppProcess.Service;
@@ -88,7 +88,7 @@ function make(proc, input) {
       const base = options?.base ?? (yield* git.defaultBranch(ctx.directory))?.ref;
       const ref = base ? yield* git.mergeBase(ctx.directory, base) : undefined;
       if (!ref) {
-        return yield* new DiffError({
+        return yield* new DiffError2({
           message: base ? `No merge base available for ${base}` : "No review base available"
         });
       }
@@ -221,7 +221,7 @@ function makeGit(proc) {
       return null;
     const current = yield* branch(cwd);
     if (!current)
-      return yield* new DiffError({ message: "Choose a review base" });
+      return yield* new DiffError2({ message: "Choose a review base" });
     const history = (yield* lines(["reflog", "show", "--max-count=256", "--format=%H%x00%gs", `refs/heads/${current}`], {
       cwd
     })).flatMap((line) => {
@@ -232,25 +232,25 @@ function makeGit(proc) {
     const creation = renamed ? undefined : history.find((entry) => entry.message.startsWith("branch: Created from "));
     const origin = creation?.message.slice("branch: Created from ".length);
     if (creation && origin) {
-      const candidate2 = yield* namedRef(cwd, origin);
-      if (candidate2 && candidate2.name !== current && (yield* ancestor(cwd, creation.commit, "HEAD")) && (yield* ancestor(cwd, creation.commit, candidate2.ref))) {
-        return { ...candidate2, source: "reflog" };
+      const candidate = yield* namedRef(cwd, origin);
+      if (candidate && candidate.name !== current && (yield* ancestor(cwd, creation.commit, "HEAD")) && (yield* ancestor(cwd, creation.commit, candidate.ref))) {
+        return { ...candidate, source: "reflog" };
       }
     }
     const root = yield* defaultBranch(cwd);
     if (!root || current !== root.name)
-      return yield* new DiffError({ message: "Choose a review base" });
+      return yield* new DiffError2({ message: "Choose a review base" });
     const candidate = yield* namedRef(cwd, root.ref);
     if (!candidate)
-      return yield* new DiffError({ message: "The default review base is unavailable" });
+      return yield* new DiffError2({ message: "The default review base is unavailable" });
     return { name: root.name, ref: candidate.ref, source: "default" };
   });
   const hasHead = Effect.fn("VcsGit.hasHead")(function* (cwd) {
     const result = yield* run(["rev-parse", "--verify", "HEAD"], { cwd });
     return result.exitCode === 0;
   });
-  const mergeBase = Effect.fn("VcsGit.mergeBase")(function* (cwd, base2) {
-    const ref = yield* resolve(cwd, base2);
+  const mergeBase = Effect.fn("VcsGit.mergeBase")(function* (cwd, base) {
+    const ref = yield* resolve(cwd, base);
     if (!ref)
       return;
     const result = yield* run(["merge-base", ref, "HEAD"], { cwd });
@@ -270,7 +270,7 @@ function makeGit(proc) {
   const diff = Effect.fn("VcsGit.diffNames")(function* (cwd, ref, target) {
     const result = yield* run(["diff", "--no-ext-diff", "--no-renames", "--name-status", "-z", ref, ...target ? [target] : [], "--", "."], { cwd });
     if (result.exitCode !== 0)
-      return yield* new DiffError({ message: "Unable to list Git changes" });
+      return yield* new DiffError2({ message: "Unable to list Git changes" });
     const list = nuls(result.text());
     return list.flatMap((code, idx) => {
       if (idx % 2 !== 0)
@@ -394,40 +394,40 @@ var batchPatches = Effect.fnUntraced(function* (ctx, ref, list, options) {
     return emptyBatch();
   const result = yield* ctx.git.patchAll(ctx.directory, ref, {
     target: options?.target,
-    context: options?.context ?? PATCH_CONTEXT_LINES,
-    maxOutputBytes: MAX_TOTAL_PATCH_BYTES
+    context: options?.context ?? PATCH_CONTEXT_LINES2,
+    maxOutputBytes: MAX_TOTAL_PATCH_BYTES2
   });
   return {
-    patches: chunksByFile(result, (index) => list[index]?.file),
+    patches: chunksByFile2(result, (index) => list[index]?.file),
     capped: result.truncated
   };
 });
 var nativePatch = Effect.fnUntraced(function* (ctx, ref, item, options) {
   const result = item.code === "??" || !ref ? yield* ctx.git.patchUntracked(ctx.worktree, item.file, {
-    context: options?.context ?? PATCH_CONTEXT_LINES,
-    maxOutputBytes: MAX_PATCH_BYTES
+    context: options?.context ?? PATCH_CONTEXT_LINES2,
+    maxOutputBytes: MAX_PATCH_BYTES2
   }) : yield* ctx.git.patch(ctx.worktree, ref, item.file, {
     target: options?.target,
-    context: options?.context ?? PATCH_CONTEXT_LINES,
-    maxOutputBytes: MAX_PATCH_BYTES
+    context: options?.context ?? PATCH_CONTEXT_LINES2,
+    maxOutputBytes: MAX_PATCH_BYTES2
   });
   if (!result.truncated && result.text)
     return result.text;
-  return emptyPatch(item.file);
+  return emptyPatch2(item.file);
 });
 var totalPatch = (file, patch, total) => {
-  if (total + Buffer.byteLength(patch) <= MAX_TOTAL_PATCH_BYTES)
+  if (total + Buffer.byteLength(patch) <= MAX_TOTAL_PATCH_BYTES2)
     return { patch, capped: false };
-  return { patch: emptyPatch(file), capped: true };
+  return { patch: emptyPatch2(file), capped: true };
 };
 var patchForItem = Effect.fnUntraced(function* (ctx, ref, item, batch, capped, options) {
   if (capped)
-    return emptyPatch(item.file);
+    return emptyPatch2(item.file);
   const batched = batch.patches.get(item.file);
   if (batched !== undefined)
     return batched;
   if (item.code !== "??" && batch.capped)
-    return emptyPatch(item.file);
+    return emptyPatch2(item.file);
   return yield* nativePatch(ctx, ref, item, options);
 });
 var files = Effect.fnUntraced(function* (ctx, ref, list, map, batch, options) {
@@ -441,7 +441,7 @@ var files = Effect.fnUntraced(function* (ctx, ref, list, map, batch, options) {
     capped = capped || result.capped;
     if (!capped) {
       total += Buffer.byteLength(result.patch);
-      capped = total >= MAX_TOTAL_PATCH_BYTES;
+      capped = total >= MAX_TOTAL_PATCH_BYTES2;
     }
     next.push({
       file: item.file,
@@ -467,4 +467,4 @@ var track = Effect.fnUntraced(function* (ctx, ref, options) {
   return yield* diffAgainstRef(ctx, ref, options);
 });
 
-export { Plugin, exports_git };
+export { Plugin5, exports_git };

package/dist/chunks/command-1n22b4te.js

@@ -0,0 +1,38 @@
+import {
+  ephemeral2,
+  Service79,
+  node83
+} from "./command-pdae5shs.js";
+import {
+  __export
+} from "./command-9rqn6x4v.js";
+
+// src/plugin/sdk.ts
+var exports_sdk = {};
+__export(exports_sdk, {
+  SdkPlugins: () => exports_sdk,
+  Service: () => Service3,
+  Updated: () => Updated2,
+  layer: () => layer4,
+  node: () => node4
+});
+import { Context, Effect, Layer } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+var Updated2 = ephemeral2({ type: "sdk.plugin.updated", schema: {} });
+
+class Service3 extends Context.Service()("@opencode/SdkPlugins") {
+}
+var layer4 = Layer.effect(Service3, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const plugins = new Map;
+  let revision = 0;
+  return Service3.of({
+    register: (plugin) => Effect.sync(() => {
+      plugins.set(plugin.id, { ...plugin, revision: String(++revision), source: { type: "sdk" } });
+    }).pipe(Effect.andThen(bus.publish(Updated2, {})), Effect.asVoid),
+    all: () => [...plugins.values()]
+  });
+}));
+var node4 = makeGlobalNode({ service: Service3, layer: layer4, deps: [node83] });
+
+export { Updated2, Service3, layer4, node4, exports_sdk };

package/dist/chunks/command-21r38tys.js

@@ -0,0 +1,14 @@
+import {
+  __export
+} from "./command-9rqn6x4v.js";
+
+// src/v1/config/layout.ts
+var exports_layout = {};
+__export(exports_layout, {
+  ConfigLayoutV1: () => exports_layout,
+  Layout: () => Layout2
+});
+import { Schema } from "effect";
+var Layout2 = Schema.Literals(["auto", "stretch"]).annotate({ identifier: "LayoutConfig" });
+
+export { Layout2, exports_layout };

package/dist/chunks/{integration-s32nnj3r.js → command-2402vzrj.js}

@@ -1,45 +1,45 @@
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/repository.ts
 var exports_repository = {};
 __export(exports_repository, {
-  InvalidBranchError: () => InvalidBranchError,
-  InvalidReferenceError: () => InvalidReferenceError,
+  InvalidBranchError: () => InvalidBranchError3,
+  InvalidReferenceError: () => InvalidReferenceError2,
   Repository: () => exports_repository,
-  UnsupportedLocalRepositoryError: () => UnsupportedLocalRepositoryError,
-  cacheIdentity: () => cacheIdentity,
-  cachePath: () => cachePath,
-  isFile: () => isFile,
-  isRemote: () => isRemote,
-  parse: () => parse,
-  parseRemote: () => parseRemote,
-  same: () => same,
-  validateBranch: () => validateBranch
+  UnsupportedLocalRepositoryError: () => UnsupportedLocalRepositoryError2,
+  cacheIdentity: () => cacheIdentity2,
+  cachePath: () => cachePath2,
+  isFile: () => isFile2,
+  isRemote: () => isRemote2,
+  parse: () => parse4,
+  parseRemote: () => parseRemote2,
+  same: () => same2,
+  validateBranch: () => validateBranch3
 });
 import path from "path";
 import { fileURLToPath } from "url";
 import { Schema } from "effect";
 
-class InvalidReferenceError extends Schema.TaggedError()("RepositoryInvalidReferenceError", {
+class InvalidReferenceError2 extends Schema.TaggedError()("RepositoryInvalidReferenceError", {
   repository: Schema.String,
   message: Schema.String
 }) {
 }
 
-class UnsupportedLocalRepositoryError extends Schema.TaggedError()("RepositoryUnsupportedLocalRepositoryError", {
+class UnsupportedLocalRepositoryError2 extends Schema.TaggedError()("RepositoryUnsupportedLocalRepositoryError", {
   repository: Schema.String,
   message: Schema.String
 }) {
 }
 
-class InvalidBranchError extends Schema.TaggedError()("RepositoryInvalidBranchError", {
+class InvalidBranchError3 extends Schema.TaggedError()("RepositoryInvalidBranchError", {
   branch: Schema.String,
   message: Schema.String
 }) {
 }
-function parse(input) {
+function parse4(input) {
   const cleaned = normalizeInput(input);
   if (!cleaned)
     return;
@@ -71,45 +71,45 @@ function parse(input) {
     return;
   }
 }
-function parseRemote(input) {
-  const reference = parse(input);
+function parseRemote2(input) {
+  const reference = parse4(input);
   if (!reference) {
-    throw new InvalidReferenceError({
+    throw new InvalidReferenceError2({
       repository: input,
       message: "Repository must be a git URL, host/path reference, or GitHub owner/repo shorthand"
     });
   }
-  if (!isRemote(reference)) {
-    throw new UnsupportedLocalRepositoryError({
+  if (!isRemote2(reference)) {
+    throw new UnsupportedLocalRepositoryError2({
       repository: input,
       message: "Local file repositories are not supported"
     });
   }
   return reference;
 }
-function validateBranch(branch) {
+function validateBranch3(branch) {
   if (/^[A-Za-z0-9/_.-]+$/.test(branch) && !branch.startsWith("-") && !branch.includes(".."))
     return;
-  throw new InvalidBranchError({
+  throw new InvalidBranchError3({
     branch,
     message: "Branch must contain only alphanumeric characters, /, _, ., and -, and cannot start with - or contain .."
   });
 }
-function isFile(reference) {
+function isFile2(reference) {
   return reference.protocol === "file:";
 }
-function isRemote(reference) {
-  return !isFile(reference);
+function isRemote2(reference) {
+  return !isFile2(reference);
 }
-function cachePath(root, reference, branch) {
+function cachePath2(root, reference, branch) {
   const base = path.join(root, ...reference.host.split(":"), ...reference.segments);
   return branch ? `${base}@${encodeURIComponent(branch)}` : base;
 }
-function cacheIdentity(reference) {
+function cacheIdentity2(reference) {
   return `${reference.host}/${reference.path}`;
 }
-function same(left, right) {
-  return cacheIdentity(left) === cacheIdentity(right);
+function same2(left, right) {
+  return cacheIdentity2(left) === cacheIdentity2(right);
 }
 function normalizeInput(input) {
   return input.trim().replace(/^git\+/, "").replace(/#.*$/, "").replace(/\/+$/, "");
@@ -172,4 +172,4 @@ function buildFile(input) {
   };
 }
 
-export { InvalidReferenceError, UnsupportedLocalRepositoryError, InvalidBranchError, parse, parseRemote, validateBranch, isFile, isRemote, cachePath, cacheIdentity, same, exports_repository };
+export { InvalidReferenceError2, UnsupportedLocalRepositoryError2, InvalidBranchError3, parse4, parseRemote2, validateBranch3, isFile2, isRemote2, cachePath2, cacheIdentity2, same2, exports_repository };

package/dist/chunks/{integration-7g39fyx9.js → command-26x1nfsd.js}

@@ -1,31 +1,31 @@
 import {
-  exports_mcp
-} from "./integration-b5zj5y7v.js";
+  Service57
+} from "./command-tr5yhgb5.js";
 import {
-  exports_config
-} from "./integration-q3j0tvwr.js";
+  Service36
+} from "./command-pcednt3p.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/config/plugin/mcp.ts
 var exports_mcp2 = {};
 __export(exports_mcp2, {
   ConfigMcpPlugin: () => exports_mcp2,
-  Plugin: () => Plugin,
-  register: () => register
+  Plugin: () => Plugin25,
+  register: () => register2
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect, Stream } from "effect";
-var Plugin = define({
+var Plugin25 = define({
   id: "opencode.config.mcp",
   effect: Effect.fn(function* (ctx) {
-    yield* register(ctx.event.subscribe());
+    yield* register2(ctx.event.subscribe());
   })
 });
-var register = Effect.fn("ConfigMCPPlugin.register")(function* (events) {
-  const config = yield* exports_config.Service;
-  const mcp = yield* exports_mcp.Service;
+var register2 = Effect.fn("ConfigMCPPlugin.register")(function* (events) {
+  const config = yield* Service57;
+  const mcp = yield* Service36;
   const loaded = { entries: [] };
   yield* events.pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(() => config.entries().pipe(Effect.tap((entries) => Effect.sync(() => loaded.entries = entries)), Effect.andThen(mcp.reload()), Effect.catchCause((cause) => Effect.logError("failed to reload MCP config", { cause })))), Effect.ignore, Effect.forkScoped({ startImmediately: true }));
   loaded.entries = yield* config.entries();
@@ -46,4 +46,4 @@ var register = Effect.fn("ConfigMCPPlugin.register")(function* (events) {
   });
 });
 
-export { Plugin, register, exports_mcp2 as exports_mcp };
+export { Plugin25, register2, exports_mcp2 };

package/dist/chunks/{integration-zsf8rs93.js → command-2710q6r3.js}

@@ -1,13 +1,13 @@
 // src/event/sql.ts
 import { sqliteTable, text, integer, index, uniqueIndex } from "drizzle-orm/sqlite-core";
-var EventSequenceTable = sqliteTable("event_sequence", {
+var EventSequenceTable2 = sqliteTable("event_sequence", {
   aggregate_id: text().notNull().primaryKey(),
   seq: integer().notNull(),
   owner_id: text()
 });
-var EventTable = sqliteTable("event", {
+var EventTable2 = sqliteTable("event", {
   id: text().$type().primaryKey(),
-  aggregate_id: text().notNull().references(() => EventSequenceTable.aggregate_id, { onDelete: "cascade" }),
+  aggregate_id: text().notNull().references(() => EventSequenceTable2.aggregate_id, { onDelete: "cascade" }),
   seq: integer().notNull(),
   created: integer().notNull().default(0),
   type: text().notNull(),
@@ -17,4 +17,4 @@ var EventTable = sqliteTable("event", {
   index("event_aggregate_type_seq_idx").on(table.aggregate_id, table.type, table.seq)
 ]);
 
-export { EventSequenceTable, EventTable };
+export { EventSequenceTable2, EventTable2 };