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

package/dist/chunks/{schema-nj42wcp7.js → event-logger-kxch3v52.js}

@@ -1,30 +1,33 @@
 import {
-  exports_driver
-} from "./schema-zyyhrfr9.js";
+  Service80,
+  node85
+} from "./event-logger-4vtp7hga.js";
 import {
-  WorkspaceTable
-} from "./schema-61ek4hj9.js";
+  makeUnsafe2
+} from "./event-logger-y71avatq.js";
 import {
-  exports_keyed_mutex
-} from "./schema-66mds5ht.js";
+  Binding2,
+  RegistryService2,
+  node71
+} from "./event-logger-r08t1rec.js";
 import {
-  exports_database
-} from "./schema-8scqw7rh.js";
+  WorkspaceTable2
+} from "./event-logger-faypxj3z.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/workspace.ts
 var exports_workspace = {};
 __export(exports_workspace, {
-  CreateConflict: () => CreateConflict,
-  ID: () => ID,
-  Info: () => Info,
-  NotFound: () => NotFound,
-  Service: () => Service,
+  CreateConflict: () => CreateConflict2,
+  ID: () => ID7,
+  Info: () => Info21,
+  NotFound: () => NotFound3,
+  Service: () => Service66,
   Workspace: () => exports_workspace,
-  configured: () => configured,
-  node: () => node
+  configured: () => configured11,
+  node: () => node70
 });
 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 ID7 = Workspace.ID;
 
-class Info extends Schema.Class("Workspace.Info")({
-  id: ID,
+class Info21 extends Schema.Class("Workspace.Info")({
+  id: ID7,
   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: ID7 }) {
 }
 
-class CreateConflict extends Schema.TaggedError()("Workspace.CreateConflict", {
-  workspaceID: ID,
+class CreateConflict2 extends Schema.TaggedError()("Workspace.CreateConflict", {
+  workspaceID: ID7,
   provider: Schema.String,
   existingProvider: Schema.String
 }) {
 }
 
-class Service extends Context.Service()("@opencode/Workspace") {
+class Service66 extends Context.Service()("@opencode/Workspace") {
 }
-var configured = (options = {}) => makeGlobalNode({
-  service: Service,
+var configured11 = (options = {}) => makeGlobalNode({
+  service: Service66,
   layer: layer(options),
-  deps: [exports_database.node, exports_driver.node]
+  deps: [node85, node71]
 });
-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(Service66, 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 Info21({
     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 Service66.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 ?? ID7.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 node70 = configured11();
 
-export { ID, Info, NotFound, CreateConflict, Service, configured, node, exports_workspace };
+export { ID7, Info21, NotFound3, CreateConflict2, Service66, configured11, node70, exports_workspace };

package/dist/chunks/{schema-7480bqmm.js → event-logger-m3eazqpa.js}

@@ -1,74 +1,80 @@
 import {
-  exports_instructions
-} from "./schema-c54e84vp.js";
+  ephemeral2,
+  Service79,
+  node84
+} from "./event-logger-jbmjz4v3.js";
 import {
-  exports_state
-} from "./schema-j6s3yjyb.js";
+  Key4,
+  unavailable3,
+  removed2,
+  make20,
+  diffByKey2
+} from "./event-logger-1z80kc63.js";
 import {
-  AbsolutePath
-} from "./schema-j07kk359.js";
+  AbsolutePath2
+} from "./event-logger-p8qxwesx.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  create3
+} from "./event-logger-kg06axw8.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/instruction-discovery.ts
 var exports_instruction_discovery = {};
 __export(exports_instruction_discovery, {
-  Event: () => Event,
-  File: () => File,
+  Event: () => Event8,
+  File: () => File2,
   InstructionDiscovery: () => exports_instruction_discovery,
-  Options: () => Options,
-  Service: () => Service,
-  configured: () => configured,
-  layer: () => layer,
-  node: () => node
+  Options: () => Options5,
+  Service: () => Service42,
+  configured: () => configured5,
+  layer: () => layer19,
+  node: () => node45
 });
 import { Context, Effect, Layer, Schema } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { createPatch } from "diff";
-class File extends Schema.Class("InstructionDiscovery.File")({
-  path: AbsolutePath,
+class File2 extends Schema.Class("InstructionDiscovery.File")({
+  path: AbsolutePath2,
   content: Schema.String
 }) {
 }
-var Files = Schema.Array(File);
-var key = exports_instructions.Key.make("core/instructions");
-var Event = {
-  Updated: exports_bus.ephemeral({ type: "instruction-discovery.updated", schema: {} })
+var Files = Schema.Array(File2);
+var key = Key4.make("core/instructions");
+var Event8 = {
+  Updated: ephemeral2({ type: "instruction-discovery.updated", schema: {} })
 };
-var Options = Schema.Struct({
+var Options5 = Schema.Struct({
   project: Schema.optional(Schema.Boolean),
   global: Schema.optional(Schema.Boolean)
 });
 
-class Service extends Context.Service()("@opencode/InstructionDiscovery") {
+class Service42 extends Context.Service()("@opencode/InstructionDiscovery") {
 }
-var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
-  const bus = yield* exports_bus.Service;
-  const state = exports_state.create({
+var layer19 = (options) => Layer.effect(Service42, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const state = create3({
     name: "instruction-discovery",
     initial: () => ({ files: new Map, available: true }),
     editor: (editor) => ({
       list: () => Array.from(editor.files.values()),
-      add: (file) => editor.files.set(file.path, new File(file)),
+      add: (file) => editor.files.set(file.path, new File2(file)),
       update: (path, update) => {
-        const current = editor.files.get(AbsolutePath.make(path));
+        const current = editor.files.get(AbsolutePath2.make(path));
         if (!current)
           return;
         update(current);
-        current.path = AbsolutePath.make(path);
+        current.path = AbsolutePath2.make(path);
       },
-      remove: (path) => editor.files.delete(AbsolutePath.make(path)),
+      remove: (path) => editor.files.delete(AbsolutePath2.make(path)),
       unavailable: () => {
         editor.available = false;
       }
     }),
-    notify: () => bus.publish(Event.Updated, {}).pipe(Effect.asVoid)
+    notify: () => bus.publish(Event8.Updated, {}).pipe(Effect.asVoid)
   });
-  const source = (value) => exports_instructions.make({
+  const source = (value) => make20({
     key,
     codec: Schema.toCodecJson(Files),
     read: Effect.succeed(value),
@@ -81,10 +87,10 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
   const list = Effect.fn("InstructionDiscovery.list")(function* () {
     const current = state.get();
     if (!current.available)
-      return exports_instructions.unavailable;
+      return unavailable3;
     return Array.from(current.files.values());
   });
-  return Service.of({
+  return Service42.of({
     project: options?.project !== false,
     global: options?.global !== false,
     transform: state.transform,
@@ -94,18 +100,18 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
       const files = yield* list();
       if (!Array.isArray(files))
         return source(files);
-      return source(files.length === 0 ? exports_instructions.removed : files);
+      return source(files.length === 0 ? removed2 : files);
     })
   });
 }));
-function configured(options) {
+function configured5(options) {
   return makeLocationNode({
-    service: Service,
-    layer: layer(options),
-    deps: [exports_bus.node]
+    service: Service42,
+    layer: layer19(options),
+    deps: [node84]
   });
 }
-var node = configured();
+var node45 = configured5();
 function render(files) {
   return files.map((file) => `Instructions from: ${file.path}
 ${file.content}`).join(`
@@ -113,7 +119,7 @@ ${file.content}`).join(`
 `);
 }
 function renderUpdate(previous, current) {
-  const changes = exports_instructions.diffByKey(previous, current, (file) => file.path, (before, after) => before.content !== after.content);
+  const changes = diffByKey2(previous, current, (file) => file.path, (before, after) => before.content !== after.content);
   return [
     ...changes.removed.map((file) => `The instructions from ${file.path} no longer apply.`),
     ...changes.added.map((file) => `New instructions apply from:
@@ -136,4 +142,4 @@ ${render([after])}`;
 `);
 }
 
-export { File, Event, Options, Service, layer, configured, node, exports_instruction_discovery };
+export { File2, Event8, Options5, Service42, layer19, configured5, node45, exports_instruction_discovery };

package/dist/chunks/{schema-j8tff6ta.js → event-logger-m6rmdee7.js}

@@ -1,48 +1,49 @@
 import {
-  exports_state
-} from "./schema-j6s3yjyb.js";
+  Service79,
+  node84
+} from "./event-logger-jbmjz4v3.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  create3
+} from "./event-logger-kg06axw8.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/command.ts
-var exports_command = {};
-__export(exports_command, {
-  Command: () => exports_command,
-  Event: () => Event,
-  ExecutionError: () => ExecutionError,
-  Info: () => Info,
-  NotFoundError: () => NotFoundError,
-  Service: () => Service,
-  layer: () => layer,
-  node: () => node
+var exports_command4 = {};
+__export(exports_command4, {
+  Command: () => exports_command4,
+  Event: () => Event7,
+  ExecutionError: () => ExecutionError2,
+  Info: () => Info7,
+  NotFoundError: () => NotFoundError4,
+  Service: () => Service41,
+  layer: () => layer18,
+  node: () => node44
 });
 import { Command } from "@opencode-ai/schema/command";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";
-import { Event } from "@opencode-ai/schema/command";
-var Info = Command.Info;
+import { Event as Event7 } from "@opencode-ai/schema/command";
+var Info7 = Command.Info;
 
-class NotFoundError extends Schema.TaggedError()("Command.NotFoundError", {
+class NotFoundError4 extends Schema.TaggedError()("Command.NotFoundError", {
   command: Schema.String,
   message: Schema.String
 }) {
 }
 
-class ExecutionError extends Schema.TaggedError()("Command.ExecutionError", {
+class ExecutionError2 extends Schema.TaggedError()("Command.ExecutionError", {
   command: Schema.String,
   message: Schema.String
 }) {
 }
 
-class Service extends Context.Service()("@opencode/Command") {
+class Service41 extends Context.Service()("@opencode/Command") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const bus = yield* exports_bus.Service;
-  const state = exports_state.create({
+var layer18 = Layer.effect(Service41, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const state = create3({
     name: "command",
     initial: () => new Map,
     editor: (editor) => ({
@@ -50,11 +51,11 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     }),
     notify: () => bus.publish(Command.Event.Updated, {}).pipe(Effect.asVoid)
   });
-  const info = (definition) => Info.make({
+  const info = (definition) => Info7.make({
     name: definition.name,
     description: definition.description
   });
-  return Service.of({
+  return Service41.of({
     reload: state.reload,
     transform: state.transform,
     get: Effect.fn("Command.get")((name) => Effect.sync(() => {
@@ -65,15 +66,15 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     execute: Effect.fn("Command.execute")(function* (input) {
       const definition = state.get().get(input.name);
       if (!definition)
-        return yield* new NotFoundError({ command: input.name, message: `Command not found: ${input.name}` });
-      return yield* definition.execute(input.invocation).pipe(Effect.tapError((error) => Effect.logError("command execution failed", { command: input.name, error })), Effect.mapError((error) => new ExecutionError({ command: input.name, message: errorMessage(error) })));
+        return yield* new NotFoundError4({ command: input.name, message: `Command not found: ${input.name}` });
+      return yield* definition.execute(input.invocation).pipe(Effect.tapError((error) => Effect.logError("command execution failed", { command: input.name, error })), Effect.mapError((error) => new ExecutionError2({ command: input.name, message: errorMessage(error) })));
     })
   });
 }));
-var node = makeLocationNode({
-  service: Service,
-  layer,
-  deps: [exports_bus.node]
+var node44 = makeLocationNode({
+  service: Service41,
+  layer: layer18,
+  deps: [node84]
 });
 function errorMessage(error) {
   if (error instanceof Error)
@@ -85,4 +86,4 @@ function errorMessage(error) {
   return "Command execution failed";
 }
 
-export { Info, NotFoundError, ExecutionError, Service, layer, node, exports_command, Event };
+export { Info7, NotFoundError4, ExecutionError2, Service41, layer18, node44, exports_command4, Event7 };

package/dist/chunks/{schema-j0feex7e.js → event-logger-m9w0rfyh.js}

@@ -1,10 +1,10 @@
 import {
-  getTableColumnsRuntime,
-  getTableLikeName,
-  getViewSelectedFieldsRuntime,
-  mapUpdateSet,
-  orderSelectedFields
-} from "./schema-k8b45nas.js";
+  getTableColumnsRuntime2,
+  getViewSelectedFieldsRuntime2,
+  orderSelectedFields2,
+  mapUpdateSet2,
+  getTableLikeName2
+} from "./event-logger-emrn6kk6.js";
 
 // src/database/drizzle/sqlite-core/effect/update.ts
 import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
@@ -14,7 +14,7 @@ import { SQLiteTable } from "drizzle-orm/sqlite-core/table";
 import { extractUsedTable } from "drizzle-orm/sqlite-core/utils";
 import { SQLiteViewBase } from "drizzle-orm/sqlite-core/view-base";
 import { Subquery } from "drizzle-orm/subquery";
-class SQLiteEffectUpdateBuilder {
+class SQLiteEffectUpdateBuilder2 {
   table;
   session;
   dialect;
@@ -27,11 +27,11 @@ class SQLiteEffectUpdateBuilder {
     this.withList = withList;
   }
   set(values) {
-    return new SQLiteEffectUpdateBase(this.table, mapUpdateSet(this.table, values), this.session, this.dialect, this.withList);
+    return new SQLiteEffectUpdateBase2(this.table, mapUpdateSet2(this.table, values), this.session, this.dialect, this.withList);
   }
 }
 
-class SQLiteEffectUpdateBase {
+class SQLiteEffectUpdateBase2 {
   effectSession;
   effectDialect;
   static [entityKind] = "SQLiteEffectUpdate";
@@ -47,13 +47,13 @@ class SQLiteEffectUpdateBase {
   }
   createJoin(joinType) {
     return (table, on) => {
-      const tableName = getTableLikeName(table);
+      const tableName = getTableLikeName2(table);
       if (typeof tableName === "string" && this.config.joins.some((join) => join.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (typeof on === "function") {
-        const from = this.config.from ? is(table, SQLiteTable) ? getTableColumnsRuntime(table) : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? getViewSelectedFieldsRuntime(table).selectedFields : undefined : undefined;
-        on = on(new Proxy(getTableColumnsRuntime(this.config.table), new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })), from && new Proxy(from, new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })));
+        const from = this.config.from ? is(table, SQLiteTable) ? getTableColumnsRuntime2(table) : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? getViewSelectedFieldsRuntime2(table).selectedFields : undefined : undefined;
+        on = on(new Proxy(getTableColumnsRuntime2(this.config.table), new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })), from && new Proxy(from, new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })));
       }
       this.config.joins.push({ on, table, joinType, alias: tableName });
       return this;
@@ -69,7 +69,7 @@ class SQLiteEffectUpdateBase {
   }
   orderBy(...columns) {
     if (typeof columns[0] === "function") {
-      const orderBy = columns[0](new Proxy(getTableColumnsRuntime(this.config.table), new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })));
+      const orderBy = columns[0](new Proxy(getTableColumnsRuntime2(this.config.table), new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })));
       this.config.orderBy = Array.isArray(orderBy) ? orderBy : [orderBy];
       return this;
     }
@@ -80,8 +80,8 @@ class SQLiteEffectUpdateBase {
     this.config.limit = limit;
     return this;
   }
-  returning(fields = getTableColumnsRuntime(this.config.table)) {
-    this.config.returning = orderSelectedFields(fields);
+  returning(fields = getTableColumnsRuntime2(this.config.table)) {
+    this.config.returning = orderSelectedFields2(fields);
     return this;
   }
   getSQL() {
@@ -118,6 +118,6 @@ class SQLiteEffectUpdateBase {
     return this;
   }
 }
-applyEffectWrapper(SQLiteEffectUpdateBase);
+applyEffectWrapper(SQLiteEffectUpdateBase2);
 
-export { SQLiteEffectUpdateBuilder, SQLiteEffectUpdateBase };
+export { SQLiteEffectUpdateBuilder2, SQLiteEffectUpdateBase2 };

package/dist/chunks/event-logger-mntxs535.js

@@ -0,0 +1,5 @@
+// src/session/event.ts
+export * from "@opencode-ai/schema/session-event";
+import * as SessionEvent2 from "@opencode-ai/schema/session-event";
+
+export { SessionEvent2 };

package/dist/chunks/{schema-db3nafyd.js → event-logger-mp43ttd6.js}

@@ -1,19 +1,23 @@
 import {
-  exports_reference
-} from "./schema-xbmv659f.js";
+  Service62,
+  node66
+} from "./event-logger-v6fy9za8.js";
 import {
-  exports_instructions
-} from "./schema-c54e84vp.js";
+  Key4,
+  removed2,
+  make20,
+  diffByKey2
+} from "./event-logger-1z80kc63.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/reference/instructions.ts
-var exports_instructions2 = {};
-__export(exports_instructions2, {
-  ReferenceInstructions: () => exports_instructions2,
-  Service: () => Service,
-  node: () => node
+var exports_instructions3 = {};
+__export(exports_instructions3, {
+  ReferenceInstructions: () => exports_instructions3,
+  Service: () => Service32,
+  node: () => node35
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";
@@ -37,7 +41,7 @@ var render = (references) => [
 ].join(`
 `);
 var update = (previous, current) => {
-  const diff = exports_instructions.diffByKey(previous, current, (reference) => reference.name, (before, after) => before.path !== after.path || before.description !== after.description);
+  const diff = diffByKey2(previous, current, (reference) => reference.name, (before, after) => before.path !== after.path || before.description !== after.description);
   if (diff.changed.length > 0 || diff.added.length === 0 && diff.removed.length === 0)
     return [
       "The available project references have changed. This list supersedes the previous reference list.",
@@ -53,21 +57,21 @@ var update = (previous, current) => {
 `);
 };
 
-class Service extends Context.Service()("@opencode/ReferenceInstructions") {
+class Service32 extends Context.Service()("@opencode/ReferenceInstructions") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const references = yield* exports_reference.Service;
-  return Service.of({
+var layer = Layer.effect(Service32, Effect.gen(function* () {
+  const references = yield* Service62;
+  return Service32.of({
     load: Effect.fn("ReferenceInstructions.load")(function* () {
       const available = (yield* references.list()).filter((reference) => reference.description !== undefined).map((reference) => ({
         name: reference.name,
         path: reference.path,
         description: reference.description
       })).toSorted((a, b) => a.name.localeCompare(b.name));
-      return exports_instructions.make({
-        key: exports_instructions.Key.make("core/reference-guidance"),
+      return make20({
+        key: Key4.make("core/reference-guidance"),
         codec: Schema.toCodecJson(Schema.Array(Summary)),
-        read: Effect.succeed(available.length === 0 ? exports_instructions.removed : available),
+        read: Effect.succeed(available.length === 0 ? removed2 : available),
         render: {
           initial: render,
           changed: update,
@@ -77,6 +81,6 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     })
   });
 }));
-var node = makeLocationNode({ service: Service, layer, deps: [exports_reference.node] });
+var node35 = makeLocationNode({ service: Service32, layer, deps: [node66] });
 
-export { Service, node, exports_instructions2 as exports_instructions };
+export { Service32, node35, exports_instructions3 };

package/dist/chunks/event-logger-mq9r6drf.js

@@ -0,0 +1,7 @@
+// src/session/schema.ts
+import * as SessionSchema2 from "@opencode-ai/schema/session";
+import { Session } from "@opencode-ai/schema/session";
+var ID15 = Session.ID;
+var Info28 = Session.Info;
+
+export { ID15, Info28, SessionSchema2 };