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

package/dist/chunks/schema-a6mq1kfm.js

@@ -1,451 +0,0 @@
-import {
-  exports_message_updater
-} from "./schema-273erafq.js";
-import {
-  exports_inbox
-} from "./schema-3rcd4hwd.js";
-import {
-  exports_instruction_entry
-} from "./schema-p0ye3rhn.js";
-import {
-  exports_instruction_state
-} from "./schema-8c5xq4gn.js";
-import {
-  SessionInboxTable,
-  SessionMessageTable,
-  SessionTable
-} from "./schema-q606pcse.js";
-import {
-  SessionMessage
-} from "./schema-8rpfd2h6.js";
-import {
-  SessionEvent
-} from "./schema-a83yvq99.js";
-import {
-  Slug
-} from "./schema-df3v2q6j.js";
-import {
-  ProjectTable
-} from "./schema-c8ya26sa.js";
-import {
-  AbsolutePath,
-  RelativePath
-} from "./schema-j07kk359.js";
-import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
-import {
-  exports_database
-} from "./schema-8scqw7rh.js";
-import {
-  __export
-} from "./schema-vpjkya7h.js";
-
-// src/session/projector.ts
-var exports_projector = {};
-__export(exports_projector, {
-  SessionAlreadyProjected: () => SessionAlreadyProjected,
-  SessionProjector: () => exports_projector,
-  node: () => node
-});
-import { and, asc, desc, eq, gt, gte, inArray, isNull, lt, lte, or, sql } from "drizzle-orm";
-import { DateTime, Effect, Layer, Schema, Stream } from "effect";
-import path from "path";
-import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
-import { Agent } from "@opencode-ai/schema/agent";
-import { Model } from "@opencode-ai/schema/model";
-import { Workspace } from "@opencode-ai/schema/workspace";
-import { FSUtil } from "@opencode-ai/util/fs-util";
-import { Money } from "@opencode-ai/schema/money";
-import { Worktree } from "@opencode-ai/schema/worktree";
-import { Project } from "@opencode-ai/schema/project";
-var decodeMessage = Schema.decodeUnknownSync(SessionMessage.Info);
-var encodeMessage = Schema.encodeSync(SessionMessage.Info);
-
-class SessionAlreadyProjected extends Error {
-}
-var ForkBatchSize = 500;
-var forkTitle = (value) => {
-  if (value === undefined)
-    return;
-  const match = value.match(/^(.+) \(fork #(\d+)\)$/);
-  if (match)
-    return `${match[1]} (fork #${Number.parseInt(match[2], 10) + 1})`;
-  return `${value} (fork #1)`;
-};
-function applyUsage(db, sessionID, value) {
-  return db.update(SessionTable).set({
-    cost: sql`${SessionTable.cost} + ${value.cost}`,
-    tokens_input: sql`${SessionTable.tokens_input} + ${value.tokens.input}`,
-    tokens_output: sql`${SessionTable.tokens_output} + ${value.tokens.output}`,
-    tokens_reasoning: sql`${SessionTable.tokens_reasoning} + ${value.tokens.reasoning}`,
-    tokens_cache_read: sql`${SessionTable.tokens_cache_read} + ${value.tokens.cache.read}`,
-    tokens_cache_write: sql`${SessionTable.tokens_cache_write} + ${value.tokens.cache.write}`,
-    time_updated: sql`${SessionTable.time_updated}`
-  }).where(eq(SessionTable.id, sessionID)).run().pipe(Effect.orDie);
-}
-var publishSessionUsage = Effect.fn("SessionProjector.publishUsage")(function* (db, bus, sessionID) {
-  const row = yield* db.select({
-    cost: SessionTable.cost,
-    input: SessionTable.tokens_input,
-    output: SessionTable.tokens_output,
-    reasoning: SessionTable.tokens_reasoning,
-    cacheRead: SessionTable.tokens_cache_read,
-    cacheWrite: SessionTable.tokens_cache_write
-  }).from(SessionTable).where(eq(SessionTable.id, sessionID)).get().pipe(Effect.orDie);
-  if (!row)
-    return;
-  yield* bus.publish(SessionEvent.UsageUpdated, {
-    sessionID,
-    cost: Money.USD.make(row.cost),
-    tokens: {
-      input: row.input,
-      output: row.output,
-      reasoning: row.reasoning,
-      cache: { read: row.cacheRead, write: row.cacheWrite }
-    }
-  });
-});
-var projectFork = Effect.fn("SessionProjector.projectFork")(function* (db, event) {
-  const parent = yield* db.select().from(SessionTable).where(eq(SessionTable.id, event.data.parentID)).get().pipe(Effect.orDie);
-  if (!parent)
-    return yield* Effect.die(new Error(`Fork parent session not found: ${event.data.parentID}`));
-  const boundary = yield* db.select({ seq: SessionMessageTable.seq }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, event.data.parentID), eq(SessionMessageTable.id, event.data.boundary.messageID))).get().pipe(Effect.orDie);
-  if (!boundary)
-    return yield* Effect.die(new Error(`Fork boundary message not found: ${event.data.boundary.messageID}`));
-  const copied = yield* db.select({ seq: SessionMessageTable.seq }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, event.data.parentID), event.data.boundary.type === "before" ? lt(SessionMessageTable.seq, boundary.seq) : lte(SessionMessageTable.seq, boundary.seq))).orderBy(desc(SessionMessageTable.seq)).limit(1).get().pipe(Effect.orDie);
-  const copiedSeq = copied?.seq;
-  const stored = yield* db.insert(SessionTable).values({
-    id: event.data.sessionID,
-    parent_id: null,
-    fork_session_id: event.data.parentID,
-    fork_boundary: event.data.boundary,
-    project_id: parent.project_id,
-    workspace_id: parent.workspace_id,
-    slug: Slug.create(),
-    directory: parent.directory,
-    path: parent.path,
-    title: forkTitle(parent.title ?? undefined),
-    agent: parent.agent,
-    model: parent.model,
-    metadata: parent.metadata,
-    version: parent.version,
-    cost: 0,
-    tokens_input: 0,
-    tokens_output: 0,
-    tokens_reasoning: 0,
-    tokens_cache_read: 0,
-    tokens_cache_write: 0,
-    time_created: event.created,
-    time_updated: event.created
-  }).onConflictDoNothing().returning({ sessionID: SessionTable.id }).get().pipe(Effect.orDie);
-  if (!stored)
-    return yield* Effect.die(new SessionAlreadyProjected);
-  if (event.data.instructionEntries)
-    yield* exports_instruction_entry.initialize(db, event.data.sessionID, event.data.instructionEntries, event.created);
-  let cursor = -1;
-  while (copiedSeq !== undefined) {
-    const rows = yield* db.select().from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, event.data.parentID), gt(SessionMessageTable.seq, cursor), lt(SessionMessageTable.seq, copiedSeq + 1), sql`${SessionMessageTable.type} != 'assistant' or json_extract(${SessionMessageTable.data}, '$.time.completed') is not null`, sql`${SessionMessageTable.type} != 'shell' or json_extract(${SessionMessageTable.data}, '$.status') != 'running'`, sql`${SessionMessageTable.type} != 'compaction' or json_extract(${SessionMessageTable.data}, '$.status') != 'running'`)).orderBy(asc(SessionMessageTable.seq)).limit(ForkBatchSize).all().pipe(Effect.orDie);
-    if (rows.length === 0)
-      break;
-    yield* db.insert(SessionMessageTable).values(rows.map((row) => ({
-      id: SessionMessage.ID.make(`${SessionMessage.ID.fromEvent(event.id)}_${row.seq}`),
-      session_id: event.data.sessionID,
-      type: row.type,
-      seq: row.seq,
-      time_created: row.time_created,
-      time_updated: row.time_updated,
-      data: row.data
-    }))).run().pipe(Effect.orDie);
-    cursor = rows.at(-1).seq;
-  }
-  if (copiedSeq !== undefined)
-    yield* exports_bus.reserveSequence(db, event.data.sessionID, copiedSeq);
-  if (event.data.instructions)
-    yield* exports_instruction_state.initialize(db, event.data.sessionID, event.durable.seq, event.data.instructions);
-});
-function run(db, event) {
-  return Effect.gen(function* () {
-    const decodeRow = (row) => decodeMessage({ ...row.data, id: row.id, type: row.type });
-    const updateMessage = (message) => {
-      const encoded = encodeMessage(message);
-      const { id, type, ...data } = encoded;
-      return db.update(SessionMessageTable).set({ type, time_created: DateTime.toEpochMillis(message.time.created), data }).where(and(eq(SessionMessageTable.id, SessionMessage.ID.make(id)), eq(SessionMessageTable.session_id, event.data.sessionID))).run().pipe(Effect.orDie);
-    };
-    const appendMessage = (message) => insertMessage(db, event, message);
-    const adapter = {
-      getAgent() {
-        return db.select({ agent: SessionTable.agent }).from(SessionTable).where(eq(SessionTable.id, event.data.sessionID)).get().pipe(Effect.orDie, Effect.map((row) => row?.agent ? Agent.ID.make(row.agent) : undefined));
-      },
-      getModel() {
-        return db.select({ model: SessionTable.model }).from(SessionTable).where(eq(SessionTable.id, event.data.sessionID)).get().pipe(Effect.orDie, Effect.map((row) => row?.model ? Schema.decodeUnknownSync(Model.Ref)(row.model) : undefined));
-      },
-      getLocation() {
-        return db.select({
-          directory: SessionTable.directory,
-          workspaceID: SessionTable.workspace_id,
-          projectID: SessionTable.project_id,
-          subpath: SessionTable.path
-        }).from(SessionTable).where(eq(SessionTable.id, event.data.sessionID)).get().pipe(Effect.orDie, Effect.map((row) => row ? {
-          location: {
-            directory: AbsolutePath.make(row.directory),
-            workspaceID: row.workspaceID ? Workspace.ID.make(row.workspaceID) : undefined
-          },
-          projectID: row.projectID,
-          subpath: row.subpath === null ? undefined : RelativePath.make(row.subpath)
-        } : undefined));
-      },
-      getCurrentAssistant() {
-        return Effect.gen(function* () {
-          const row = yield* db.select().from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, event.data.sessionID), eq(SessionMessageTable.type, "assistant"))).orderBy(desc(SessionMessageTable.seq)).limit(1).get().pipe(Effect.orDie);
-          if (!row)
-            return;
-          const message = decodeRow(row);
-          return message.type === "assistant" && !message.time.completed ? message : undefined;
-        });
-      },
-      getAssistant(messageID) {
-        return Effect.gen(function* () {
-          const row = yield* db.select().from(SessionMessageTable).where(and(eq(SessionMessageTable.id, messageID), eq(SessionMessageTable.session_id, event.data.sessionID), eq(SessionMessageTable.type, "assistant"))).get().pipe(Effect.orDie);
-          if (!row)
-            return;
-          const message = decodeRow(row);
-          return message.type === "assistant" ? message : undefined;
-        });
-      },
-      getShell(shellID) {
-        return Effect.gen(function* () {
-          const row = yield* db.select().from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, event.data.sessionID), eq(SessionMessageTable.type, "shell"), sql`json_extract(${SessionMessageTable.data}, '$.shellID') = ${shellID}`)).orderBy(desc(SessionMessageTable.seq)).limit(1).get().pipe(Effect.orDie);
-          if (!row)
-            return;
-          const message = decodeRow(row);
-          return message.type === "shell" ? message : undefined;
-        });
-      },
-      getCompaction() {
-        return Effect.gen(function* () {
-          const row = yield* db.select().from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, event.data.sessionID), eq(SessionMessageTable.type, "compaction"), sql`json_extract(${SessionMessageTable.data}, '$.status') = 'running'`)).orderBy(desc(SessionMessageTable.seq)).limit(1).get().pipe(Effect.orDie);
-          if (!row)
-            return;
-          const message = decodeRow(row);
-          return message.type === "compaction" ? message : undefined;
-        });
-      },
-      updateAssistant: updateMessage,
-      updateShell: updateMessage,
-      updateCompaction: updateMessage,
-      appendMessage
-    };
-    yield* exports_message_updater.update(adapter, event);
-  });
-}
-function insertMessage(db, event, message) {
-  const encoded = encodeMessage(message);
-  const { id, type, ...data } = encoded;
-  return db.insert(SessionMessageTable).values({
-    id: SessionMessage.ID.make(id),
-    session_id: event.data.sessionID,
-    type,
-    seq: event.durable.seq,
-    time_created: DateTime.toEpochMillis(message.time.created),
-    data
-  }).run().pipe(Effect.orDie);
-}
-function projectIdle(db, event) {
-  return Effect.gen(function* () {
-    yield* run(db, event);
-    if (event.type === SessionEvent.Execution.Interrupted.type && event.data.reason === "shutdown")
-      return;
-    const time = event.created;
-    const outcome = event.type === SessionEvent.Execution.Succeeded.type ? "succeeded" : event.type === SessionEvent.Execution.Failed.type ? "failed" : "interrupted";
-    yield* db.update(SessionTable).set({
-      time_idle: sql`max(${time}, coalesce(${SessionTable.time_idle} + 1, ${time}))`,
-      idle_outcome: outcome,
-      time_updated: sql`${SessionTable.time_updated}`
-    }).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie);
-  });
-}
-var layer = Layer.effectDiscard(Effect.gen(function* () {
-  const bus = yield* exports_bus.Service;
-  const db = (yield* exports_database.Service).db;
-  yield* bus.project(SessionEvent.Created, (event) => Effect.gen(function* () {
-    const stored = yield* db.insert(SessionTable).values({
-      id: event.data.sessionID,
-      project_id: event.data.projectID,
-      workspace_id: event.data.location.workspaceID ? Workspace.ID.make(event.data.location.workspaceID) : null,
-      parent_id: event.data.parentID,
-      slug: event.data.slug,
-      directory: event.data.location.directory,
-      path: event.data.subpath,
-      title: event.data.title,
-      agent: event.data.agent,
-      model: event.data.model,
-      metadata: event.data.metadata,
-      version: event.data.version,
-      time_created: event.created,
-      time_updated: event.created
-    }).onConflictDoNothing().returning({ sessionID: SessionTable.id }).get().pipe(Effect.orDie);
-    if (!stored)
-      return yield* Effect.die(new SessionAlreadyProjected);
-  }));
-  yield* bus.project(SessionEvent.Moved, (event) => Effect.gen(function* () {
-    yield* run(db, event);
-    yield* db.update(SessionTable).set({
-      directory: event.data.location.directory,
-      path: event.data.subpath,
-      ...event.data.projectID ? { project_id: event.data.projectID } : {},
-      workspace_id: event.data.location.workspaceID ? Workspace.ID.make(event.data.location.workspaceID) : null,
-      time_updated: event.created
-    }).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie);
-  }));
-  yield* bus.project(Worktree.Event.Resolved, (event) => Effect.gen(function* () {
-    const candidates = [
-      ...new Set([event.data.previous, Project.ID.global, ...event.data.adopted ?? []].filter((id) => id !== event.data.projectID))
-    ];
-    if (candidates.length === 0)
-      return;
-    const rows = yield* db.select({
-      id: SessionTable.id,
-      directory: SessionTable.directory,
-      projectID: SessionTable.project_id,
-      canonical: ProjectTable.worktree
-    }).from(SessionTable).innerJoin(ProjectTable, eq(SessionTable.project_id, ProjectTable.id)).where(and(inArray(SessionTable.project_id, candidates), isNull(SessionTable.workspace_id), or(event.data.adopted?.length ? inArray(SessionTable.project_id, event.data.adopted) : undefined, and(gte(SessionTable.directory, event.data.directory), lte(SessionTable.directory, AbsolutePath.make(event.data.directory + "￿")))))).all().pipe(Effect.orDie);
-    yield* Effect.forEach(rows, (row) => {
-      const directory = event.data.adopted?.includes(row.projectID) ? row.canonical : AbsolutePath.make(path.resolve(row.directory));
-      if (!FSUtil.contains(event.data.directory, directory))
-        return Effect.void;
-      return db.update(SessionTable).set({
-        project_id: event.data.projectID,
-        path: RelativePath.make(path.relative(event.data.directory, directory).replaceAll("\\", "/")),
-        time_updated: sql`${SessionTable.time_updated}`
-      }).where(eq(SessionTable.id, row.id)).run().pipe(Effect.orDie);
-    }, { discard: true });
-  }));
-  yield* bus.project(SessionEvent.Deleted, (event) => db.delete(SessionTable).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie));
-  yield* bus.project(SessionEvent.AgentSelected, (event) => Effect.gen(function* () {
-    yield* run(db, event);
-    yield* db.update(SessionTable).set({ agent: event.data.agent, time_updated: event.created }).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie);
-  }));
-  yield* bus.project(SessionEvent.ModelSelected, (event) => Effect.gen(function* () {
-    yield* run(db, event);
-    yield* db.update(SessionTable).set({ model: event.data.model, time_updated: event.created }).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie);
-  }));
-  yield* bus.project(SessionEvent.Renamed, (event) => db.update(SessionTable).set({ title: event.data.title, time_updated: event.created }).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie));
-  yield* bus.project(SessionEvent.Viewed, (event) => {
-    const idle = event.data.idle;
-    return db.update(SessionTable).set({
-      time_viewed: sql`max(${idle}, coalesce(${SessionTable.time_viewed}, ${idle}))`,
-      time_updated: sql`${SessionTable.time_updated}`
-    }).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie);
-  });
-  yield* bus.project(SessionEvent.MessageContentUpdated, (event) => run(db, event));
-  yield* bus.project(SessionEvent.UsageRecorded, (event) => applyUsage(db, event.data.sessionID, event.data));
-  yield* bus.project(SessionEvent.Forked, (event) => projectFork(db, event));
-  yield* bus.project(SessionEvent.InboxDelivered, (event) => Effect.gen(function* () {
-    const input = yield* exports_inbox.projectDelivered(db, {
-      id: event.data.inboxID,
-      sessionID: event.data.sessionID
-    });
-    if (input.type === "compaction" || input.type === "move")
-      return;
-    yield* insertMessage(db, event, input.type === "user" ? {
-      id: input.id,
-      type: "user",
-      metadata: input.payload.metadata,
-      text: input.payload.text,
-      files: input.payload.files,
-      agents: input.payload.agents,
-      skills: input.payload.skills,
-      time: { created: DateTime.makeUnsafe(event.created) }
-    } : {
-      id: input.id,
-      type: "synthetic",
-      text: input.payload.text,
-      description: input.payload.description,
-      metadata: input.payload.metadata,
-      time: { created: DateTime.makeUnsafe(event.created) }
-    });
-  }));
-  yield* bus.project(SessionEvent.InboxEnqueued, (event) => Effect.gen(function* () {
-    yield* exports_inbox.projectAdmitted(db, {
-      enqueuedSeq: event.durable.seq,
-      id: event.data.inboxID,
-      sessionID: event.data.sessionID,
-      item: event.data.item,
-      timeCreated: event.created
-    });
-    yield* db.update(SessionTable).set({ time_updated: event.created }).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie);
-  }));
-  yield* bus.project(SessionEvent.InboxCancelled, (event) => exports_inbox.projectCancelled(db, {
-    id: event.data.inboxID,
-    sessionID: event.data.sessionID
-  }));
-  yield* bus.project(SessionEvent.InboxDeliveryChanged, (event) => exports_inbox.projectDeliveryChanged(db, {
-    id: event.data.inboxID,
-    sessionID: event.data.sessionID,
-    delivery: event.data.delivery
-  }));
-  yield* bus.project(SessionEvent.Execution.Succeeded, (event) => projectIdle(db, event));
-  yield* bus.project(SessionEvent.Execution.Failed, (event) => projectIdle(db, event));
-  yield* bus.project(SessionEvent.Execution.Interrupted, (event) => projectIdle(db, event));
-  yield* bus.project(SessionEvent.InstructionsUpdated, (event) => Effect.gen(function* () {
-    yield* run(db, event);
-    yield* exports_instruction_state.apply(db, event.data.sessionID, event.durable.seq, event.data.delta);
-  }));
-  yield* bus.project(SessionEvent.Synthetic, (event) => run(db, event));
-  yield* bus.project(SessionEvent.Skill.Activated, (event) => run(db, event));
-  yield* bus.project(SessionEvent.Shell.Started, (event) => run(db, event));
-  yield* bus.project(SessionEvent.Shell.Ended, (event) => run(db, event));
-  yield* bus.project(SessionEvent.Step.Started, (event) => run(db, event));
-  yield* bus.project(SessionEvent.Step.Streamed, (event) => run(db, event));
-  yield* bus.project(SessionEvent.Step.Ended, (event) => Effect.gen(function* () {
-    yield* run(db, event);
-    yield* applyUsage(db, event.data.sessionID, event.data);
-  }));
-  yield* bus.project(SessionEvent.Step.Failed, (event) => Effect.gen(function* () {
-    yield* run(db, event);
-    if (event.data.cost !== undefined && event.data.tokens !== undefined)
-      yield* applyUsage(db, event.data.sessionID, { cost: event.data.cost, tokens: event.data.tokens });
-  }));
-  yield* bus.project(SessionEvent.Text.Started, (event) => run(db, event));
-  yield* bus.project(SessionEvent.Text.Ended, (event) => run(db, event));
-  yield* bus.project(SessionEvent.Tool.Input.Started, (event) => run(db, event));
-  yield* bus.project(SessionEvent.Tool.Input.Ended, (event) => run(db, event));
-  yield* bus.project(SessionEvent.Tool.Called, (event) => run(db, event));
-  yield* bus.project(SessionEvent.Tool.Success, (event) => run(db, event));
-  yield* bus.project(SessionEvent.Tool.Failed, (event) => run(db, event));
-  yield* bus.project(SessionEvent.Reasoning.Started, (event) => run(db, event));
-  yield* bus.project(SessionEvent.Reasoning.Ended, (event) => run(db, event));
-  yield* bus.project(SessionEvent.RetryScheduled, (event) => run(db, event));
-  yield* bus.project(SessionEvent.Compaction.Started, (event) => run(db, event));
-  yield* bus.project(SessionEvent.Compaction.Ended, (event) => Effect.gen(function* () {
-    yield* run(db, event);
-    yield* exports_instruction_state.advanceEpoch(db, event.data.sessionID, event.durable.seq);
-  }));
-  yield* bus.project(SessionEvent.Compaction.Failed, (event) => run(db, event));
-  yield* bus.project(SessionEvent.RevertEvent.Staged, (event) => Effect.gen(function* () {
-    const revert = event.data.revert;
-    yield* db.update(SessionTable).set({
-      revert: { ...revert, files: revert.files ? [...revert.files] : undefined },
-      time_updated: event.created
-    }).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie);
-  }));
-  yield* bus.project(SessionEvent.RevertEvent.Cleared, (event) => db.update(SessionTable).set({ revert: null, time_updated: event.created }).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie, Effect.asVoid));
-  yield* bus.project(SessionEvent.RevertEvent.Committed, (event) => Effect.gen(function* () {
-    const boundary = yield* db.select({ seq: SessionMessageTable.seq }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, event.data.sessionID), eq(SessionMessageTable.id, event.data.to))).get().pipe(Effect.orDie);
-    if (!boundary)
-      return yield* Effect.die(new Error(`Revert boundary message not found: ${event.data.to}`));
-    yield* db.delete(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, event.data.sessionID), gte(SessionMessageTable.seq, boundary.seq))).run().pipe(Effect.orDie);
-    yield* db.delete(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, event.data.sessionID), gte(SessionInboxTable.enqueued_seq, boundary.seq))).run().pipe(Effect.orDie);
-    yield* db.update(SessionTable).set({ revert: null, time_updated: event.created }).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie);
-    yield* exports_instruction_state.reset(db, event.data.sessionID);
-  }));
-  yield* bus.subscribe([SessionEvent.Step.Ended, SessionEvent.Step.Failed, SessionEvent.UsageRecorded]).pipe(Stream.runForEach((event) => {
-    if (event.type === SessionEvent.Step.Failed.type && (event.data.cost === undefined || event.data.tokens === undefined))
-      return Effect.void;
-    return publishSessionUsage(db, bus, event.data.sessionID);
-  }), Effect.forkScoped({ startImmediately: true }));
-}));
-var node = makeGlobalNode({ name: "session-projector", layer, deps: [exports_bus.node, exports_database.node] });
-
-export { SessionAlreadyProjected, node, exports_projector };

package/dist/chunks/schema-a6xqkezx.js

@@ -1,14 +0,0 @@
-import {
-  __export
-} from "./schema-vpjkya7h.js";
-
-// src/database/v1-migration.ts
-var exports_v1_migration = {};
-__export(exports_v1_migration, {
-  V1Migration: () => V1Migration
-});
-import * as V1Migration from "#v1-migration";
-
-export * from "#v1-migration";
-
-export { exports_v1_migration, V1Migration };

package/dist/chunks/schema-a83yvq99.js

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

package/dist/chunks/schema-aeh43dyz.js

@@ -1,40 +0,0 @@
-import {
-  exports_entry_observer
-} from "./schema-mnyszbxc.js";
-import {
-  exports_config
-} from "./schema-jq0ga1pd.js";
-import {
-  exports_tool_output
-} from "./schema-6b7ybj1y.js";
-import {
-  __export
-} from "./schema-vpjkya7h.js";
-
-// src/config/plugin/tool-output.ts
-var exports_tool_output2 = {};
-__export(exports_tool_output2, {
-  ConfigToolOutputPlugin: () => exports_tool_output2,
-  Plugin: () => Plugin
-});
-import { define } from "@opencode-ai/plugin/effect/plugin";
-import { Effect } from "effect";
-var Plugin = define({
-  id: "opencode.config.tool-output",
-  effect: Effect.fn(function* (ctx) {
-    const config = yield* exports_config.Service;
-    const output = yield* exports_tool_output.Service;
-    const loaded = yield* exports_entry_observer.observe(config, ctx.event, output.reload());
-    yield* output.transform((editor) => {
-      const configured = exports_config.latest(loaded.entries, "tool_output");
-      if (!configured)
-        return;
-      editor.configure({
-        ...configured.max_lines === undefined ? {} : { maxLines: configured.max_lines },
-        ...configured.max_bytes === undefined ? {} : { maxBytes: configured.max_bytes }
-      });
-    });
-  })
-});
-
-export { Plugin, exports_tool_output2 as exports_tool_output };

package/dist/chunks/schema-attsg8d3.js

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