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

package/dist/chunks/{instance-ezq2f8jv.js → kv-9rjp7yvj.js}

@@ -1,80 +1,84 @@
 import {
-  exports_revert
-} from "./instance-4zrb12b6.js";
+  Service80
+} from "./kv-3rps85z5.js";
 import {
-  exports_prompt
-} from "./instance-8jtz1kc1.js";
+  Service79
+} from "./kv-9j3fyze8.js";
 import {
-  exports_shell
-} from "./instance-4cjpbb2p.js";
+  Service40
+} from "./kv-sp5wnj6d.js";
 import {
-  exports_execution
-} from "./instance-wcxp0ga0.js";
+  userNotification2
+} from "./kv-fxbjtjnd.js";
 import {
-  exports_inbox
-} from "./instance-s1jhrg9v.js";
+  SessionMessage2
+} from "./kv-982e01ww.js";
 import {
-  exports_skill
-} from "./instance-fz2kvkjz.js";
+  NotFoundError6,
+  MessageNotFoundError2,
+  MessageNotAssistantError2,
+  MessageIncompleteError2,
+  MessageToolIncompleteError2,
+  PromptConflictError2,
+  SyntheticConflictError2,
+  CompactionConflictError2,
+  BusyError2,
+  InboxConflictError2
+} from "./kv-aw8agfgj.js";
 import {
-  exports_service
-} from "./instance-6bxzghb6.js";
+  SessionEvent2
+} from "./kv-mntxs535.js";
 import {
-  exports_store
-} from "./instance-4sxm9wb7.js";
+  Service55
+} from "./kv-0c2smd8y.js";
 import {
-  BusyError,
-  CompactionConflictError,
-  InboxConflictError,
-  MessageIncompleteError,
-  MessageNotAssistantError,
-  MessageNotFoundError,
-  MessageToolIncompleteError,
-  NotFoundError,
-  PromptConflictError,
-  SyntheticConflictError
-} from "./instance-2sqw2jjm.js";
+  Delivery2,
+  SyntheticPayload2,
+  Service25
+} from "./kv-6c7eyv5g.js";
 import {
-  SessionMessage
-} from "./instance-8rpfd2h6.js";
+  Service23
+} from "./kv-hbhn1exa.js";
 import {
-  exports_result
-} from "./instance-5y5kqjze.js";
+  prepare2
+} from "./kv-fjp933gm.js";
 import {
-  SessionEvent
-} from "./instance-a83yvq99.js";
+  stage2,
+  clear2,
+  commit2
+} from "./kv-9dcr27t6.js";
 import {
-  exports_bus
-} from "./instance-3dwd52hd.js";
+  start2
+} from "./kv-v9qvtgmd.js";
 import {
-  exports_database
-} from "./instance-5ez4e7fn.js";
+  get4
+} from "./kv-jdszapxk.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-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* Service55;
+  const instances = yield* Service40;
+  const execution = yield* Service23;
+  const admission = yield* Service25;
   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 NotFoundError6({ 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(Service40, 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(Service40, 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(Service40, 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(Service40, 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(Service40, 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/{instance-vpjkya7h.js → kv-9rqn6x4v.js}

@@ -1,4 +1,3 @@
-import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -13,7 +12,5 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
-var __require = (specifier) => createRequire(import.meta.url ?? "file:///worker.js")(specifier);
-__require.resolve = (specifier, options) => createRequire(import.meta.url ?? "file:///worker.js").resolve(specifier, options);
 
-export { __export, __require };
+export { __export };

package/dist/chunks/{instance-we6q85je.js → kv-a04vk3pp.js}

@@ -1,30 +1,33 @@
 import {
-  WorkspaceTable
-} from "./instance-61ek4hj9.js";
+  Service80,
+  node84
+} from "./kv-3rps85z5.js";
 import {
-  exports_driver
-} from "./instance-zyyhrfr9.js";
+  makeUnsafe2
+} from "./kv-jwcy2c2z.js";
 import {
-  exports_keyed_mutex
-} from "./instance-66mds5ht.js";
+  Binding2,
+  RegistryService2,
+  node67
+} from "./kv-fn7btw4k.js";
 import {
-  exports_database
-} from "./instance-5ez4e7fn.js";
+  WorkspaceTable2
+} from "./kv-faypxj3z.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/workspace.ts
 var exports_workspace = {};
 __export(exports_workspace, {
-  CreateConflict: () => CreateConflict,
-  ID: () => ID,
-  Info: () => Info,
-  NotFound: () => NotFound,
-  Service: () => Service,
+  CreateConflict: () => CreateConflict2,
+  ID: () => ID10,
+  Info: () => Info23,
+  NotFound: () => NotFound3,
+  Service: () => Service63,
   Workspace: () => exports_workspace,
-  configured: () => configured,
-  node: () => node
+  configured: () => configured9,
+  node: () => node66
 });
 import { Workspace } from "@opencode-ai/schema/workspace";
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
@@ -32,52 +35,52 @@ import { eq } from "drizzle-orm";
 import { Clock, Context, Deferred, Duration, Effect, Exit, FiberSet, Layer, Ref, Schedule, Schema, Scope } from "effect";
 import { systemError } from "effect/PlatformError";
 import { make } from "effect/unstable/process/ChildProcessSpawner";
-var ID = Workspace.ID;
+var ID10 = Workspace.ID;
 
-class Info extends Schema.Class("Workspace.Info")({
-  id: ID,
+class Info23 extends Schema.Class("Workspace.Info")({
+  id: ID10,
   provider: Schema.String,
-  binding: exports_driver.Binding,
+  binding: Binding2,
   createdAt: Schema.Number,
   lastUsedAt: Schema.Number
 }) {
 }
 
-class NotFound extends Schema.TaggedError()("Workspace.NotFound", { workspaceID: ID }) {
+class NotFound3 extends Schema.TaggedError()("Workspace.NotFound", { workspaceID: ID10 }) {
 }
 
-class CreateConflict extends Schema.TaggedError()("Workspace.CreateConflict", {
-  workspaceID: ID,
+class CreateConflict2 extends Schema.TaggedError()("Workspace.CreateConflict", {
+  workspaceID: ID10,
   provider: Schema.String,
   existingProvider: Schema.String
 }) {
 }
 
-class Service extends Context.Service()("@opencode/Workspace") {
+class Service63 extends Context.Service()("@opencode/Workspace") {
 }
-var configured = (options = {}) => makeGlobalNode({
-  service: Service,
+var configured9 = (options = {}) => makeGlobalNode({
+  service: Service63,
   layer: layer(options),
-  deps: [exports_database.node, exports_driver.node]
+  deps: [node84, node67]
 });
-var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
-  const db = (yield* exports_database.Service).db;
-  const registry = yield* exports_driver.RegistryService;
+var layer = (options) => Layer.effect(Service63, Effect.gen(function* () {
+  const db = (yield* Service80).db;
+  const registry = yield* RegistryService2;
   const lifetime = yield* Scope.Scope;
   const connections = new Map;
   const attempts = new Map;
-  const locks = exports_keyed_mutex.makeUnsafe();
+  const locks = makeUnsafe2();
   const fork = yield* FiberSet.makeRuntime();
   const idleThreshold = Duration.toMillis(options.idleThreshold ?? Duration.minutes(20));
-  const find = (workspaceID) => db.select().from(WorkspaceTable).where(eq(WorkspaceTable.id, workspaceID)).get().pipe(Effect.orDie);
+  const find = (workspaceID) => db.select().from(WorkspaceTable2).where(eq(WorkspaceTable2.id, workspaceID)).get().pipe(Effect.orDie);
   const load = Effect.fn("Workspace.load")(function* (workspaceID) {
     const row = yield* find(workspaceID);
     if (!row)
-      return yield* new NotFound({ workspaceID });
+      return yield* new NotFound3({ workspaceID });
     return row;
   });
-  const saveBinding = (workspaceID, binding) => db.update(WorkspaceTable).set({ binding }).where(eq(WorkspaceTable.id, workspaceID)).run().pipe(Effect.orDie);
-  const info = (row, binding) => new Info({
+  const saveBinding = (workspaceID, binding) => db.update(WorkspaceTable2).set({ binding }).where(eq(WorkspaceTable2.id, workspaceID)).run().pipe(Effect.orDie);
+  const info = (row, binding) => new Info23({
     id: row.id,
     provider: row.provider,
     binding,
@@ -126,7 +129,7 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
       scope
     };
     connections.set(workspaceID, connection);
-    yield* db.update(WorkspaceTable).set({ last_used_at: now }).where(eq(WorkspaceTable.id, workspaceID)).run().pipe(Effect.orDie);
+    yield* db.update(WorkspaceTable2).set({ last_used_at: now }).where(eq(WorkspaceTable2.id, workspaceID)).run().pipe(Effect.orDie);
     return connection;
   });
   yield* Effect.gen(function* () {
@@ -146,19 +149,19 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
         binding: row.binding,
         saveBinding: connection.saveBinding
       });
-      yield* db.update(WorkspaceTable).set({ last_used_at: lastActivity }).where(eq(WorkspaceTable.id, workspaceID)).run().pipe(Effect.orDie);
+      yield* db.update(WorkspaceTable2).set({ last_used_at: lastActivity }).where(eq(WorkspaceTable2.id, workspaceID)).run().pipe(Effect.orDie);
       connections.delete(workspaceID);
       yield* Scope.close(connection.scope, Exit.void);
     }).pipe(Effect.catchCause((cause) => Effect.logError("workspace idle suspension failed", cause)))), { concurrency: "unbounded", discard: true });
   }).pipe(Effect.repeat(Schedule.spaced(options.pollInterval ?? Duration.minutes(1))), Effect.forkScoped);
-  return Service.of({
+  return Service63.of({
     create: Effect.fn("Workspace.create")(function* (input) {
-      const workspaceID = input.id ?? ID.create();
-      const existing = yield* db.select({ provider: WorkspaceTable.provider }).from(WorkspaceTable).where(eq(WorkspaceTable.id, workspaceID)).get().pipe(Effect.orDie);
+      const workspaceID = input.id ?? ID10.create();
+      const existing = yield* db.select({ provider: WorkspaceTable2.provider }).from(WorkspaceTable2).where(eq(WorkspaceTable2.id, workspaceID)).get().pipe(Effect.orDie);
       if (existing) {
         if (existing.provider === input.provider)
           return workspaceID;
-        return yield* new CreateConflict({
+        return yield* new CreateConflict2({
           workspaceID,
           provider: input.provider,
           existingProvider: existing.provider
@@ -166,12 +169,12 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
       }
       yield* registry.get(input.provider);
       const now = yield* Clock.currentTimeMillis;
-      const inserted = yield* db.insert(WorkspaceTable).values({ id: workspaceID, provider: input.provider, binding: null, created_at: now, last_used_at: now }).onConflictDoNothing().returning({ id: WorkspaceTable.id }).get().pipe(Effect.orDie);
+      const inserted = yield* db.insert(WorkspaceTable2).values({ id: workspaceID, provider: input.provider, binding: null, created_at: now, last_used_at: now }).onConflictDoNothing().returning({ id: WorkspaceTable2.id }).get().pipe(Effect.orDie);
       if (inserted)
         return workspaceID;
       const row = yield* load(workspaceID).pipe(Effect.orDie);
       if (row.provider !== input.provider)
-        return yield* new CreateConflict({
+        return yield* new CreateConflict2({
           workspaceID,
           provider: input.provider,
           existingProvider: row.provider
@@ -201,7 +204,7 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
       const attempt = attempts.get(workspaceID);
       if (attempt) {
         attempts.delete(workspaceID);
-        Deferred.doneUnsafe(attempt, Exit.fail(new NotFound({ workspaceID })));
+        Deferred.doneUnsafe(attempt, Exit.fail(new NotFound3({ workspaceID })));
       }
       return yield* locks.withLock(workspaceID)(Effect.gen(function* () {
         const row = yield* find(workspaceID);
@@ -212,12 +215,12 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
         if (connection)
           yield* Scope.close(connection.scope, Exit.void);
         yield* registry.get(row.provider).pipe(Effect.flatMap((driver) => driver.destroy({ workspaceID, binding: row.binding })), Effect.catchTag("WorkspaceDriver.ProviderNotFound", (error) => row.binding ? Effect.fail(error) : Effect.void));
-        yield* db.delete(WorkspaceTable).where(eq(WorkspaceTable.id, workspaceID)).run().pipe(Effect.orDie);
+        yield* db.delete(WorkspaceTable2).where(eq(WorkspaceTable2.id, workspaceID)).run().pipe(Effect.orDie);
         return { destroyed: true };
       }));
     })
   });
 }));
-var node = configured();
+var node66 = configured9();
 
-export { ID, Info, NotFound, CreateConflict, Service, configured, node, exports_workspace };
+export { ID10, Info23, NotFound3, CreateConflict2, Service63, configured9, node66, exports_workspace };