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

package/dist/chunks/shell-ask3gap1.js

@@ -1,151 +0,0 @@
-import {
-  CredentialTable
-} from "./shell-mf0hyk7z.js";
-import {
-  exports_bus
-} from "./shell-07b0cypv.js";
-import {
-  exports_database
-} from "./shell-t1qmyghk.js";
-import {
-  __export
-} from "./shell-vpjkya7h.js";
-
-// src/credential.ts
-var exports_credential = {};
-__export(exports_credential, {
-  Credential: () => exports_credential,
-  Event: () => Event,
-  ID: () => ID,
-  Info: () => Info,
-  Key: () => Key,
-  OAuth: () => OAuth,
-  Service: () => Service,
-  Value: () => Value,
-  node: () => node
-});
-import { asc, desc, eq } from "drizzle-orm";
-import { Context, Effect, Layer, Schema } from "effect";
-import { Credential } from "@opencode-ai/schema/credential";
-import { Integration } from "@opencode-ai/schema/integration";
-import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
-var ID = Credential.ID;
-var OAuth = Credential.OAuth;
-var Key = Credential.Key;
-var Value = Credential.Value;
-var Event = Credential.Event;
-
-class Info extends Schema.Class("Credential.Info")({
-  id: ID,
-  integrationID: Integration.ID,
-  label: Schema.String,
-  value: Value
-}) {
-}
-
-class Service extends Context.Service()("@opencode/Credential") {
-}
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const db = (yield* exports_database.Service).db;
-  const bus = yield* exports_bus.Service;
-  const decode = Schema.decodeUnknownSync(Value);
-  const stored = (row) => {
-    if (!row.integration_id)
-      return;
-    return new Info({
-      id: row.id,
-      integrationID: row.integration_id,
-      label: row.label,
-      value: decode(row.value)
-    });
-  };
-  const storedRows = (rows) => rows.flatMap((row) => {
-    const credential = stored(row);
-    return credential ? [credential] : [];
-  });
-  return Service.of({
-    all: Effect.fn("Credential.all")(() => db.select().from(CredentialTable).orderBy(asc(CredentialTable.active), asc(CredentialTable.time_created), asc(CredentialTable.id)).all().pipe(Effect.orDie, Effect.map(storedRows))),
-    list: Effect.fn("Credential.list")((integrationID) => db.select().from(CredentialTable).where(eq(CredentialTable.integration_id, integrationID)).orderBy(asc(CredentialTable.active), asc(CredentialTable.time_created), asc(CredentialTable.id)).all().pipe(Effect.orDie, Effect.map(storedRows))),
-    get: Effect.fn("Credential.get")(function* (id) {
-      const row = yield* db.select().from(CredentialTable).where(eq(CredentialTable.id, id)).get().pipe(Effect.orDie);
-      return row ? stored(row) : undefined;
-    }),
-    create: Effect.fn("Credential.create")(function* (input) {
-      const credential = new Info({
-        id: ID.create(),
-        integrationID: input.integrationID,
-        label: input.label ?? "default",
-        value: input.value
-      });
-      yield* db.transaction((tx) => Effect.gen(function* () {
-        yield* tx.update(CredentialTable).set({ active: false }).where(eq(CredentialTable.integration_id, credential.integrationID)).run();
-        yield* tx.insert(CredentialTable).values({
-          id: credential.id,
-          integration_id: credential.integrationID,
-          label: credential.label,
-          value: credential.value,
-          active: true
-        }).run();
-      })).pipe(Effect.orDie);
-      yield* bus.publish(Event.Updated, {}, { global: true });
-      yield* bus.publish(Event.Switched, { integrationID: credential.integrationID, credentialID: credential.id }, { global: true });
-      return credential;
-    }),
-    activate: Effect.fn("Credential.activate")(function* (id) {
-      const integrationID = yield* db.transaction((tx) => Effect.gen(function* () {
-        const credential = yield* tx.select().from(CredentialTable).where(eq(CredentialTable.id, id)).get();
-        if (!credential?.integration_id)
-          return;
-        const active = yield* tx.select({ id: CredentialTable.id }).from(CredentialTable).where(eq(CredentialTable.integration_id, credential.integration_id)).orderBy(desc(CredentialTable.active), desc(CredentialTable.time_created), desc(CredentialTable.id)).get();
-        if (active?.id === id)
-          return;
-        yield* tx.update(CredentialTable).set({ active: false }).where(eq(CredentialTable.integration_id, credential.integration_id)).run();
-        yield* tx.update(CredentialTable).set({ active: true }).where(eq(CredentialTable.id, id)).run();
-        return credential.integration_id;
-      })).pipe(Effect.orDie);
-      if (integrationID)
-        yield* bus.publish(Event.Switched, { integrationID, credentialID: id }, { global: true });
-    }),
-    update: Effect.fn("Credential.update")(function* (id, updates) {
-      if (updates.label === undefined && updates.value === undefined)
-        return;
-      const credential = yield* db.select({ integrationID: CredentialTable.integration_id, label: CredentialTable.label }).from(CredentialTable).where(eq(CredentialTable.id, id)).get().pipe(Effect.orDie);
-      if (!credential?.integrationID)
-        return;
-      if (updates.label === credential.label && updates.value === undefined)
-        return;
-      yield* db.update(CredentialTable).set({ label: updates.label, value: updates.value }).where(eq(CredentialTable.id, id)).run().pipe(Effect.orDie);
-      if (updates.label !== undefined && updates.label !== credential.label)
-        yield* bus.publish(Event.Updated, {}, { global: true });
-    }),
-    remove: Effect.fn("Credential.remove")(function* (id) {
-      const removed = yield* db.transaction((tx) => Effect.gen(function* () {
-        const credential = yield* tx.select().from(CredentialTable).where(eq(CredentialTable.id, id)).get();
-        if (!credential)
-          return;
-        const active = credential.integration_id ? yield* tx.select({ id: CredentialTable.id }).from(CredentialTable).where(eq(CredentialTable.integration_id, credential.integration_id)).orderBy(desc(CredentialTable.active), desc(CredentialTable.time_created), desc(CredentialTable.id)).get() : undefined;
-        yield* tx.delete(CredentialTable).where(eq(CredentialTable.id, id)).run();
-        if (!credential.integration_id || active?.id !== id)
-          return { switched: false };
-        const replacement = yield* tx.select({ id: CredentialTable.id }).from(CredentialTable).where(eq(CredentialTable.integration_id, credential.integration_id)).orderBy(desc(CredentialTable.time_created), desc(CredentialTable.id)).get();
-        if (replacement) {
-          yield* tx.update(CredentialTable).set({ active: false }).where(eq(CredentialTable.integration_id, credential.integration_id)).run();
-          yield* tx.update(CredentialTable).set({ active: true }).where(eq(CredentialTable.id, replacement.id)).run();
-        }
-        return {
-          switched: true,
-          integrationID: credential.integration_id,
-          credentialID: replacement?.id ?? null
-        };
-      })).pipe(Effect.orDie);
-      if (!removed)
-        return;
-      yield* bus.publish(Event.Updated, {}, { global: true });
-      if (removed.switched)
-        yield* bus.publish(Event.Switched, { integrationID: removed.integrationID, credentialID: removed.credentialID }, { global: true });
-    })
-  });
-}));
-var node = makeGlobalNode({ service: Service, layer, deps: [exports_database.node, exports_bus.node] });
-
-export { ID, OAuth, Key, Value, Event, Info, Service, node, exports_credential };

package/dist/chunks/shell-bjwj8hwv.js

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

package/dist/chunks/shell-c8ya26sa.js

@@ -1,41 +0,0 @@
-import {
-  absoluteArrayColumn,
-  absoluteColumn
-} from "./shell-zbqqnp0n.js";
-import {
-  Timestamps
-} from "./shell-sem2g21k.js";
-
-// src/project/sql.ts
-import { isNotNull, isNull, ne, or } from "drizzle-orm";
-import { sqliteTable, text, integer, primaryKey } from "drizzle-orm/sqlite-core";
-var ProjectTable = sqliteTable("project", {
-  id: text().$type().primaryKey(),
-  worktree: absoluteColumn().notNull(),
-  vcs: text().$type(),
-  name: text(),
-  icon_url: text(),
-  icon_url_override: text(),
-  icon_color: text(),
-  ...Timestamps,
-  time_initialized: integer(),
-  sandboxes: absoluteArrayColumn().notNull(),
-  commands: text({ mode: "json" }).$type()
-});
-var ProjectDirectoryTable = sqliteTable("project_directory", {
-  project_id: text().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
-  directory: absoluteColumn().notNull(),
-  type: text().$type(),
-  strategy: text(),
-  time_created: integer().notNull().$default(() => Date.now())
-}, (table) => [primaryKey({ columns: [table.project_id, table.directory] })]);
-function upsertProject(db, project) {
-  const vcs = project.vcs?.type;
-  return db.insert(ProjectTable).values({ id: project.id, worktree: project.canonical, vcs, sandboxes: [] }).onConflictDoUpdate({
-    target: ProjectTable.id,
-    set: { vcs: vcs ?? null },
-    setWhere: vcs ? or(isNull(ProjectTable.vcs), ne(ProjectTable.vcs, vcs)) : isNotNull(ProjectTable.vcs)
-  }).run();
-}
-
-export { ProjectTable, ProjectDirectoryTable, upsertProject };

package/dist/chunks/shell-cpsjz0c7.js

@@ -1,31 +0,0 @@
-import {
-  DefaultServices,
-  EffectSQLiteDatabase,
-  make,
-  makeWithDefaults
-} from "./shell-r7gm0yzj.js";
-import {
-  EffectSQLiteSession,
-  EffectSQLiteTransaction,
-  managesTransactionsNatively
-} from "./shell-kk70vshc.js";
-import {
-  __export
-} from "./shell-vpjkya7h.js";
-
-// src/database/drizzle/index.ts
-var exports_drizzle = {};
-__export(exports_drizzle, {
-  DefaultServices: () => DefaultServices,
-  EffectDrizzleSqlite: () => exports_drizzle,
-  EffectLogger: () => EffectLogger,
-  EffectSQLiteDatabase: () => EffectSQLiteDatabase,
-  EffectSQLiteSession: () => EffectSQLiteSession,
-  EffectSQLiteTransaction: () => EffectSQLiteTransaction,
-  make: () => make,
-  makeWithDefaults: () => makeWithDefaults,
-  managesTransactionsNatively: () => managesTransactionsNatively
-});
-import { EffectLogger } from "drizzle-orm/effect-core";
-
-export { exports_drizzle, EffectLogger };

package/dist/chunks/shell-ehj9csmv.js

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

package/dist/chunks/shell-esv5q40e.js

@@ -1,18 +0,0 @@
-import {
-  __export
-} from "./shell-vpjkya7h.js";
-
-// src/plugin/service.ts
-var exports_service = {};
-__export(exports_service, {
-  Plugin: () => exports_service,
-  Service: () => Service,
-  awaitActivation: () => awaitActivation
-});
-import { Context } from "effect";
-
-class Service extends Context.Service()("@opencode/Plugin") {
-}
-var awaitActivation = Service.use((plugins) => plugins.awaitActivation);
-
-export { Service, awaitActivation, exports_service };

package/dist/chunks/shell-f16sbr11.js

@@ -1,40 +0,0 @@
-import {
-  exports_entry_observer
-} from "./shell-mnyszbxc.js";
-import {
-  exports_config
-} from "./shell-r8f3g7x9.js";
-import {
-  exports_tool_output
-} from "./shell-7gcyy9x5.js";
-import {
-  __export
-} from "./shell-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/shell-gc513wew.js

@@ -1,25 +0,0 @@
-import {
-  AbsolutePath
-} from "./shell-j07kk359.js";
-import {
-  __export
-} from "./shell-vpjkya7h.js";
-
-// src/worktree/directory.ts
-var exports_directory = {};
-__export(exports_directory, {
-  DirectoryUnavailableError: () => DirectoryUnavailableError,
-  WorktreeDirectory: () => exports_directory,
-  canonical: () => canonical
-});
-import { Effect, Schema } from "effect";
-class DirectoryUnavailableError extends Schema.TaggedError()("Worktree.DirectoryUnavailableError", { directory: AbsolutePath }) {
-}
-var canonical = Effect.fnUntraced(function* (fs, input) {
-  const resolved = AbsolutePath.make(yield* fs.resolve(input));
-  if (!(yield* fs.isDir(resolved)))
-    return yield* new DirectoryUnavailableError({ directory: input });
-  return resolved;
-});
-
-export { DirectoryUnavailableError, canonical, exports_directory };

package/dist/chunks/shell-grfz4hhj.js

@@ -1,14 +0,0 @@
-import {
-  __export
-} from "./shell-vpjkya7h.js";
-
-// src/file.ts
-var exports_file = {};
-__export(exports_file, {
-  Diff: () => Diff,
-  File: () => exports_file
-});
-import { FileDiff } from "@opencode-ai/schema/file-diff";
-var Diff = FileDiff.Info;
-
-export { Diff, exports_file };

package/dist/chunks/shell-h5f8a9ks.js

@@ -1,319 +0,0 @@
-import {
-  SessionInboxTable,
-  SessionMessageTable
-} from "./shell-q606pcse.js";
-import {
-  SessionEvent
-} from "./shell-a83yvq99.js";
-import {
-  SessionMessage
-} from "./shell-8rpfd2h6.js";
-import {
-  SessionSchema
-} from "./shell-bjwj8hwv.js";
-import {
-  exports_bus
-} from "./shell-07b0cypv.js";
-import {
-  exports_database
-} from "./shell-t1qmyghk.js";
-import {
-  exports_keyed_mutex
-} from "./shell-66mds5ht.js";
-import {
-  __export
-} from "./shell-vpjkya7h.js";
-
-// src/session/inbox.ts
-var exports_inbox = {};
-__export(exports_inbox, {
-  Compaction: () => Compaction,
-  CompactionPayload: () => CompactionPayload,
-  Delivery: () => Delivery,
-  Info: () => Info,
-  Item: () => Item,
-  LifecycleConflict: () => LifecycleConflict,
-  Move: () => Move,
-  MovePayload: () => MovePayload,
-  Service: () => Service,
-  SessionInbox: () => exports_inbox,
-  Synthetic: () => Synthetic,
-  SyntheticPayload: () => SyntheticPayload,
-  User: () => User,
-  UserPayload: () => UserPayload,
-  find: () => find,
-  has: () => has,
-  layer: () => layer,
-  list: () => list,
-  make: () => make,
-  moveIDs: () => moveIDs,
-  nextPromotable: () => nextPromotable,
-  node: () => node,
-  projectAdmitted: () => projectAdmitted,
-  projectCancelled: () => projectCancelled,
-  projectDelivered: () => projectDelivered,
-  projectDeliveryChanged: () => projectDeliveryChanged,
-  promote: () => promote,
-  serialized: () => serialized
-});
-import { and, asc, eq, or } from "drizzle-orm";
-import { Context, DateTime, Effect, Layer, Schema } from "effect";
-import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
-import {
-  Compaction,
-  CompactionPayload,
-  Delivery,
-  Info,
-  Item,
-  Move,
-  MovePayload,
-  Synthetic,
-  SyntheticPayload,
-  User,
-  UserPayload
-} from "@opencode-ai/schema/session-inbox";
-var decodeUser = Schema.decodeUnknownSync(UserPayload);
-var encodeUser = Schema.encodeSync(UserPayload);
-var decodeSynthetic = Schema.decodeUnknownSync(SyntheticPayload);
-var encodeSynthetic = Schema.encodeSync(SyntheticPayload);
-var decodeCompaction = Schema.decodeUnknownSync(CompactionPayload);
-var encodeCompaction = Schema.encodeSync(CompactionPayload);
-var decodeMove = Schema.decodeUnknownSync(MovePayload);
-var encodeMove = Schema.encodeSync(MovePayload);
-var decodeMessage = Schema.decodeUnknownSync(SessionMessage.Info);
-var inboxLocks = exports_keyed_mutex.makeUnsafe();
-var serialized = (sessionID, effect) => inboxLocks.withLock(sessionID)(effect);
-
-class LifecycleConflict extends Schema.TaggedError()("SessionInbox.LifecycleConflict", {
-  id: SessionMessage.ID
-}) {
-}
-function matches(stored, request) {
-  return stored.sessionID === request.sessionID && stored.type === request.type;
-}
-var fromRow = (row) => {
-  const base = {
-    id: SessionMessage.ID.make(row.id),
-    sessionID: SessionSchema.ID.make(row.session_id),
-    timeCreated: DateTime.makeUnsafe(row.time_created)
-  };
-  if (row.type === "compaction")
-    return Compaction.make({
-      ...base,
-      type: "compaction",
-      payload: decodeCompaction(row.payload),
-      delivery: row.delivery
-    });
-  if (row.type === "move")
-    return Move.make({ ...base, type: "move", payload: decodeMove(row.payload), delivery: row.delivery });
-  if (row.type === "user")
-    return User.make({
-      ...base,
-      type: "user",
-      payload: decodeUser(row.payload),
-      delivery: row.delivery
-    });
-  if (row.type === "synthetic")
-    return Synthetic.make({
-      ...base,
-      type: "synthetic",
-      payload: decodeSynthetic(row.payload),
-      delivery: row.delivery
-    });
-  throw new LifecycleConflict({ id: base.id });
-};
-var find = Effect.fn("SessionInbox.find")(function* (db, id) {
-  const row = yield* db.select().from(SessionInboxTable).where(eq(SessionInboxTable.id, id)).get().pipe(Effect.orDie);
-  return row === undefined ? undefined : fromRow(row);
-});
-var promotedFromMessage = Effect.fn("SessionInbox.promotedFromMessage")(function* (db, sessionID, id, delivery) {
-  const row = yield* db.select().from(SessionMessageTable).where(eq(SessionMessageTable.id, id)).get().pipe(Effect.orDie);
-  if (row === undefined)
-    return;
-  if (row.session_id !== sessionID || row.type !== "user" && row.type !== "synthetic")
-    return yield* new LifecycleConflict({ id });
-  const message = decodeMessage({ ...row.data, id: row.id, type: row.type });
-  const base = { id, sessionID, timeCreated: message.time.created, delivery };
-  if (message.type === "user")
-    return User.make({
-      ...base,
-      type: "user",
-      payload: decodeUser(message)
-    });
-  if (message.type === "synthetic")
-    return Synthetic.make({
-      ...base,
-      type: "synthetic",
-      payload: decodeSynthetic(message)
-    });
-  return yield* new LifecycleConflict({ id });
-});
-
-class Service extends Context.Service()("@opencode/SessionInbox") {
-}
-var make = Effect.fn("SessionInbox.make")(function* () {
-  const database = yield* exports_database.Service;
-  const db = database.db;
-  const bus = yield* exports_bus.Service;
-  const reconcile = Effect.fn("SessionInbox.reconcile")(function* (request) {
-    const existing = (yield* find(db, request.id)) ?? (yield* promotedFromMessage(db, request.sessionID, request.id, request.delivery));
-    if (existing === undefined)
-      return;
-    if (existing.type === "compaction" || !matches(existing, request))
-      return yield* new LifecycleConflict({ id: request.id });
-    return existing;
-  });
-  const admit = Effect.fn("SessionInbox.admit")(function* (request) {
-    const existing = yield* reconcile({ ...request, type: request.item.type, delivery: request.item.delivery });
-    if (existing !== undefined)
-      return existing;
-    const admitted = yield* bus.publish(SessionEvent.InboxEnqueued, {
-      inboxID: request.id,
-      sessionID: request.sessionID,
-      item: request.item
-    }).pipe(Effect.map((event) => Info.make({
-      id: request.id,
-      sessionID: request.sessionID,
-      timeCreated: DateTime.makeUnsafe(event.created),
-      ...request.item
-    })), Effect.catchDefect((defect) => defect instanceof LifecycleConflict ? find(db, request.id).pipe(Effect.flatMap((stored) => stored === undefined ? Effect.fail(defect) : Effect.succeed(stored))) : Effect.die(defect)));
-    if (!matches(admitted, { ...request, type: request.item.type }))
-      return yield* new LifecycleConflict({ id: request.id });
-    return admitted;
-  });
-  const admitCompaction = Effect.fn("SessionInbox.admitCompaction")(function* (input) {
-    return yield* serialized(input.sessionID, Effect.gen(function* () {
-      const exact = yield* find(db, input.id);
-      if (exact) {
-        if (exact.type === "compaction" && exact.sessionID === input.sessionID)
-          return exact;
-        return yield* new LifecycleConflict({ id: input.id });
-      }
-      if (yield* promotedFromMessage(db, input.sessionID, input.id, input.delivery))
-        return yield* new LifecycleConflict({ id: input.id });
-      const pending = (yield* list(db, input.sessionID)).find((item) => item.type === "compaction");
-      if (pending)
-        return pending;
-      return yield* admit({
-        id: input.id,
-        sessionID: input.sessionID,
-        item: { type: "compaction", payload: {}, delivery: Delivery.make(input.delivery) }
-      });
-    }));
-  });
-  const cancel = Effect.fn("SessionInbox.cancel")((input) => publishMutation(input, bus.publish(SessionEvent.InboxCancelled, {
-    sessionID: input.sessionID,
-    inboxID: input.id
-  })));
-  const steer = Effect.fn("SessionInbox.steer")((input) => publishMutation(input, bus.publish(SessionEvent.InboxDeliveryChanged, {
-    sessionID: input.sessionID,
-    inboxID: input.id,
-    delivery: "steer"
-  })));
-  const queue = Effect.fn("SessionInbox.queue")((input) => publishMutation(input, bus.publish(SessionEvent.InboxDeliveryChanged, {
-    sessionID: input.sessionID,
-    inboxID: input.id,
-    delivery: "queue"
-  })));
-  return {
-    list: (sessionID) => list(db, sessionID),
-    reconcile,
-    admit,
-    admitCompaction,
-    cancel,
-    steer,
-    queue
-  };
-});
-var layer = Layer.effect(Service, make());
-var node = makeGlobalNode({ service: Service, layer, deps: [exports_database.node, exports_bus.node] });
-var projectAdmitted = Effect.fn("SessionInbox.projectAdmitted")(function* (db, request) {
-  const message = yield* db.select({ id: SessionMessageTable.id }).from(SessionMessageTable).where(eq(SessionMessageTable.id, request.id)).get().pipe(Effect.orDie);
-  if (message !== undefined)
-    return yield* Effect.die(new LifecycleConflict({ id: request.id }));
-  const stored = yield* db.insert(SessionInboxTable).values({
-    id: request.id,
-    session_id: request.sessionID,
-    type: request.item.type,
-    payload: request.item.type === "user" ? encodeUser(request.item.payload) : request.item.type === "synthetic" ? encodeSynthetic(request.item.payload) : request.item.type === "compaction" ? encodeCompaction(request.item.payload) : encodeMove(request.item.payload),
-    delivery: request.item.delivery,
-    enqueued_seq: request.enqueuedSeq,
-    time_created: request.timeCreated
-  }).onConflictDoNothing().returning({ id: SessionInboxTable.id }).get().pipe(Effect.orDie);
-  if (!stored)
-    return yield* Effect.die(new LifecycleConflict({ id: request.id }));
-});
-var projectDelivered = Effect.fn("SessionInbox.projectDelivered")(function* (db, input) {
-  const deleted = yield* db.delete(SessionInboxTable).where(and(eq(SessionInboxTable.id, input.id), eq(SessionInboxTable.session_id, input.sessionID))).returning().get().pipe(Effect.orDie);
-  if (!deleted)
-    return yield* Effect.die(new LifecycleConflict({ id: input.id }));
-  return fromRow(deleted);
-});
-var projectCancelled = Effect.fn("SessionInbox.projectCancelled")(function* (db, input) {
-  const deleted = yield* db.delete(SessionInboxTable).where(and(eq(SessionInboxTable.id, input.id), eq(SessionInboxTable.session_id, input.sessionID), or(eq(SessionInboxTable.delivery, "queue"), eq(SessionInboxTable.delivery, "steer")))).returning({ id: SessionInboxTable.id }).get().pipe(Effect.orDie);
-  if (!deleted)
-    return yield* Effect.die(new LifecycleConflict({ id: input.id }));
-});
-var projectDelivery = Effect.fn("SessionInbox.projectDelivery")(function* (db, input) {
-  const updated = yield* db.update(SessionInboxTable).set({ delivery: input.to }).where(and(eq(SessionInboxTable.id, input.id), eq(SessionInboxTable.session_id, input.sessionID), eq(SessionInboxTable.delivery, input.from))).returning({ id: SessionInboxTable.id }).get().pipe(Effect.orDie);
-  if (!updated)
-    return yield* Effect.die(new LifecycleConflict({ id: input.id }));
-});
-var projectDeliveryChanged = Effect.fn("SessionInbox.projectDeliveryChanged")((db, input) => projectDelivery(db, {
-  ...input,
-  from: input.delivery === "steer" ? "queue" : "steer",
-  to: input.delivery
-}));
-var list = Effect.fn("SessionInbox.list")(function* (db, sessionID) {
-  const rows = yield* db.select().from(SessionInboxTable).where(eq(SessionInboxTable.session_id, sessionID)).orderBy(asc(SessionInboxTable.enqueued_seq)).all().pipe(Effect.orDie);
-  return rows.map(fromRow);
-});
-var moveIDs = Effect.fn("SessionInbox.moveIDs")(function* (db, sessionID) {
-  return yield* db.select({ id: SessionInboxTable.id }).from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.type, "move"))).orderBy(asc(SessionInboxTable.enqueued_seq)).all().pipe(Effect.orDie);
-});
-var nextPromotable = Effect.fn("SessionInbox.nextPromotable")(function* (db, sessionID, promotable) {
-  const next = (delivery) => db.select().from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, delivery))).orderBy(asc(SessionInboxTable.enqueued_seq)).limit(1).get().pipe(Effect.orDie);
-  const steer = yield* next("steer");
-  if (steer)
-    return fromRow(steer);
-  if (promotable !== "input")
-    return;
-  const queued = yield* next("queue");
-  return queued ? fromRow(queued) : undefined;
-});
-var has = Effect.fn("SessionInbox.has")(function* (db, sessionID, scope) {
-  const row = yield* db.select({ id: SessionInboxTable.id }).from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), scope === "input" ? or(eq(SessionInboxTable.delivery, "steer"), eq(SessionInboxTable.delivery, "queue")) : eq(SessionInboxTable.delivery, scope))).limit(1).get().pipe(Effect.orDie);
-  return row !== undefined;
-});
-var publishMutation = (input, effect) => serialized(input.sessionID, effect).pipe(Effect.asVoid, Effect.catchDefect((defect) => defect instanceof LifecycleConflict ? Effect.fail(defect) : Effect.die(defect)));
-var publish = Effect.fn("SessionInbox.publish")(function* (db, bus, sessionID, rows) {
-  yield* Effect.forEach(rows, (row) => {
-    const entry = fromRow(row);
-    if (entry.type === "compaction")
-      return Effect.die(new LifecycleConflict({ id: entry.id }));
-    return bus.publish(SessionEvent.InboxDelivered, {
-      sessionID,
-      inboxID: entry.id
-    }).pipe(Effect.catchDefect((defect) => defect instanceof LifecycleConflict ? promotedFromMessage(db, sessionID, entry.id, entry.delivery).pipe(Effect.flatMap((stored) => stored !== undefined ? Effect.void : Effect.die(defect)), Effect.orDie) : Effect.die(defect)));
-  }, { discard: true });
-  return rows.length;
-});
-var promote = Effect.fn("SessionInbox.promote")(function* (db, bus, sessionID, scope) {
-  return yield* serialized(sessionID, Effect.gen(function* () {
-    const steers = yield* pendingSteers(db, sessionID);
-    if (steers.length > 0 || scope === "steer") {
-      const control2 = steers.findIndex((row) => row.type === "compaction" || row.type === "move");
-      return yield* publish(db, bus, sessionID, control2 === -1 ? steers : steers.slice(0, control2));
-    }
-    const queued = yield* db.select().from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "queue"))).orderBy(asc(SessionInboxTable.enqueued_seq)).limit(1).get().pipe(Effect.orDie);
-    if (!queued)
-      return 0;
-    const promoted = yield* publish(db, bus, sessionID, [queued]);
-    const arrivedSteers = yield* pendingSteers(db, sessionID);
-    const control = arrivedSteers.findIndex((row) => row.type === "compaction" || row.type === "move");
-    return promoted + (yield* publish(db, bus, sessionID, control === -1 ? arrivedSteers : arrivedSteers.slice(0, control)));
-  }));
-});
-var pendingSteers = (db, sessionID) => db.select().from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "steer"))).orderBy(asc(SessionInboxTable.enqueued_seq)).all().pipe(Effect.orDie);
-
-export { Compaction, CompactionPayload, Delivery, Info, Item, Move, MovePayload, Synthetic, SyntheticPayload, User, UserPayload, serialized, LifecycleConflict, find, Service, make, layer, node, projectAdmitted, projectDelivered, projectCancelled, projectDeliveryChanged, list, moveIDs, nextPromotable, has, promote, exports_inbox };