@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-88jbfw8z.js

@@ -0,0 +1,41 @@
+import {
+  absoluteArrayColumn,
+  absoluteColumn
+} from "./location-mutation-zbqqnp0n.js";
+import {
+  Timestamps
+} from "./location-mutation-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: { worktree: project.canonical, vcs: vcs ?? null },
+    setWhere: or(ne(ProjectTable.worktree, project.canonical), vcs ? or(isNull(ProjectTable.vcs), ne(ProjectTable.vcs, vcs)) : isNotNull(ProjectTable.vcs))
+  }).run();
+}
+
+export { ProjectTable, ProjectDirectoryTable, upsertProject };

package/dist/chunks/location-mutation-8bkmtpp6.js

@@ -0,0 +1,56 @@
+import {
+  GET_VERSION_FOR,
+  MIGRATIONS_TABLE_VERSIONS
+} from "./location-mutation-f84sxdqn.js";
+import {
+  buildSQLiteMigrationBackfillStatements,
+  prepareSQLiteMigrationBackfill
+} from "./location-mutation-4zg0gww9.js";
+
+// src/database/drizzle/up-migrations/effect-sqlite.ts
+import * as Effect from "effect/Effect";
+import { EffectDrizzleError } from "drizzle-orm/effect-core/errors";
+import { sql } from "drizzle-orm/sql/sql";
+var migrationUpgradeError = (cause) => new EffectDrizzleError({
+  message: typeof cause === "object" && cause !== null && "message" in cause && typeof cause.message === "string" ? cause.message : String(cause),
+  cause
+});
+var upgradeIfNeeded = Effect.fn("upgradeIfNeeded")(function* (migrationsTable, session, localMigrations) {
+  const tableExists = yield* session.all(sql`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ${migrationsTable}`);
+  if (tableExists.length === 0) {
+    return { newDb: true };
+  }
+  const rows = yield* session.all(sql`SELECT name as column_name FROM pragma_table_info(${migrationsTable})`);
+  const version = GET_VERSION_FOR.sqlite(rows.map((r) => r.column_name));
+  for (let v = version;v < MIGRATIONS_TABLE_VERSIONS.sqlite; v++) {
+    const upgradeFn = upgradeFunctions[v];
+    if (!upgradeFn) {
+      return yield* new EffectDrizzleError({
+        message: `No upgrade path from migration table version ${v} to ${v + 1}`,
+        cause: { version: v }
+      });
+    }
+    yield* upgradeFn(migrationsTable, session, localMigrations);
+  }
+  return { newDb: false };
+});
+var upgradeFunctions = {
+  0: upgradeFromV0
+};
+function upgradeFromV0(migrationsTable, session, localMigrations) {
+  return Effect.gen(function* () {
+    const table = sql`${sql.identifier(migrationsTable)}`;
+    const dbRows = yield* session.all(sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`);
+    const statements = yield* Effect.try({
+      try: () => buildSQLiteMigrationBackfillStatements(migrationsTable, prepareSQLiteMigrationBackfill(dbRows, localMigrations)),
+      catch: migrationUpgradeError
+    });
+    yield* session.transaction((tx) => Effect.gen(function* () {
+      for (const statement of statements) {
+        yield* tx.run(statement);
+      }
+    }));
+  });
+}
+
+export { upgradeIfNeeded };

package/dist/chunks/location-mutation-8k8ks5a6.js

@@ -0,0 +1,196 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/instructions/index.ts
+var exports_instructions = {};
+__export(exports_instructions, {
+  unavailable: () => unavailable,
+  renderUpdate: () => renderUpdate,
+  renderInitial: () => renderInitial,
+  removed: () => removed,
+  read: () => read,
+  make: () => make,
+  hash: () => hash,
+  empty: () => empty,
+  diffByKey: () => diffByKey,
+  diff: () => diff,
+  combine: () => combine,
+  applyHashDelta: () => applyHashDelta,
+  Values: () => Values,
+  Key: () => Key,
+  Instructions: () => exports_instructions,
+  InitializationBlocked: () => InitializationBlocked,
+  Hash: () => Hash,
+  DuplicateKeyError: () => DuplicateKeyError,
+  Delta: () => Delta
+});
+import { createHash } from "crypto";
+import { Instruction } from "@opencode-ai/schema/instruction";
+import { Data, Effect, Option, Schema } from "effect";
+var Key = Instruction.Key;
+var Hash = Instruction.Hash;
+var Values = Instruction.Values;
+var Delta = Instruction.Delta;
+var NonValue = Data.taggedEnum();
+var unavailable = NonValue.Unavailable();
+var removed = NonValue.Removed();
+
+class InitializationBlocked extends Schema.TaggedErrorClass()("Instructions.InitializationBlocked", { keys: Schema.Array(Key) }) {
+  get message() {
+    return `Instruction initialization blocked by unavailable sources: ${this.keys.join(", ")}`;
+  }
+}
+
+class DuplicateKeyError extends Schema.TaggedErrorClass()("Instructions.DuplicateKeyError", {
+  key: Key
+}) {
+  get message() {
+    return `Duplicate instruction key: ${this.key}`;
+  }
+}
+var empty = [];
+function make(source) {
+  const decode = Schema.decodeUnknownOption(source.codec);
+  const encode = Schema.encodeSync(source.codec);
+  const initial = (value) => requireText(source.key, "initial", source.render.initial(value));
+  const decodeValue = (value) => Option.getOrUndefined(decode(value));
+  return [
+    {
+      key: source.key,
+      read: source.read.pipe(Effect.map((value) => {
+        if (isUnavailable(value))
+          return unavailable;
+        if (isRemoved(value))
+          return removed;
+        return encode(value);
+      })),
+      initial: (value) => {
+        const decoded = decodeValue(value);
+        return decoded === undefined ? undefined : initial(decoded);
+      },
+      changed: (previous, current) => {
+        const before = decodeValue(previous);
+        const after = decodeValue(current);
+        if (after === undefined)
+          return;
+        if (before === undefined)
+          return initial(after);
+        return requireText(source.key, "changed", source.render.changed(before, after));
+      },
+      removed: (previous) => {
+        const decoded = decodeValue(previous);
+        return decoded === undefined || source.render.removed === undefined ? undefined : requireText(source.key, "removed", source.render.removed(decoded));
+      }
+    }
+  ];
+}
+function combine(values) {
+  const sources = values.flat();
+  const keys = new Set;
+  for (const source of sources) {
+    if (keys.has(source.key))
+      throw new DuplicateKeyError({ key: source.key });
+    keys.add(source.key);
+  }
+  return sources;
+}
+function read(value) {
+  return Effect.forEach(value, (source) => source.read.pipe(Effect.map((observed) => ({ key: source.key, value: observed }))), { concurrency: "unbounded" });
+}
+function diff(observed, previous) {
+  const blocked = previous ? [] : observed.flatMap((entry) => isUnavailable(entry.value) ? [entry.key] : []);
+  if (blocked.length > 0)
+    return Effect.fail(new InitializationBlocked({ keys: blocked }));
+  const delta = {};
+  const blobs = {};
+  for (const entry of observed) {
+    if (isUnavailable(entry.value))
+      continue;
+    if (isRemoved(entry.value)) {
+      if (previous && Object.hasOwn(previous, entry.key))
+        delta[entry.key] = Instruction.removed;
+      continue;
+    }
+    const next = hash(entry.value);
+    if (previous?.[entry.key] === next)
+      continue;
+    delta[entry.key] = next;
+    blobs[next] = entry.value;
+  }
+  return Effect.succeed({ delta, blobs });
+}
+function renderInitial(value, values) {
+  return render(value.flatMap((source) => {
+    if (!Object.hasOwn(values, source.key))
+      return [];
+    const text = source.initial(values[source.key]);
+    return text === undefined ? [] : [text];
+  }));
+}
+function renderUpdate(value, previous, delta) {
+  return render(value.flatMap((source) => {
+    if (!Object.hasOwn(delta, source.key))
+      return [];
+    const current = delta[source.key];
+    if (Option.isNone(current)) {
+      if (!Object.hasOwn(previous, source.key))
+        return [];
+      const text2 = source.removed(previous[source.key]);
+      return text2 === undefined ? [] : [text2];
+    }
+    const next = current.value;
+    const text = Object.hasOwn(previous, source.key) ? source.changed(previous[source.key], next) : source.initial(next);
+    return text === undefined ? [] : [text];
+  }));
+}
+function hash(value) {
+  return Hash.make(createHash("sha256").update(canonical(value)).digest("hex"));
+}
+function applyHashDelta(values, delta) {
+  const result = { ...values };
+  for (const [key, value] of Object.entries(delta)) {
+    if (value === Instruction.removed)
+      delete result[key];
+    else
+      result[key] = value;
+  }
+  return result;
+}
+function diffByKey(previous, current, key, changed) {
+  const currentKeys = new Set(current.map(key));
+  const previousByKey = new Map(previous.map((value) => [key(value), value]));
+  return {
+    added: current.filter((value) => !previousByKey.has(key(value))),
+    removed: previous.filter((value) => !currentKeys.has(key(value))),
+    changed: current.flatMap((value) => {
+      const before = previousByKey.get(key(value));
+      return before === undefined || !changed(before, value) ? [] : [{ previous: before, current: value }];
+    })
+  };
+}
+function render(parts) {
+  return parts.join(`
+
+`);
+}
+function isUnavailable(value) {
+  return value === unavailable;
+}
+function isRemoved(value) {
+  return value === removed;
+}
+function canonical(value) {
+  if (Array.isArray(value))
+    return `[${value.map(canonical).join(",")}]`;
+  if (value !== null && typeof value === "object")
+    return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, entry]) => `${JSON.stringify(key)}:${canonical(entry)}`).join(",")}}`;
+  return JSON.stringify(value);
+}
+function requireText(key, kind, text) {
+  if (text.length === 0)
+    throw new Error(`Instruction source ${key} rendered an empty ${kind}`);
+  return text;
+}
+
+export { Key, Hash, Values, Delta, unavailable, removed, InitializationBlocked, DuplicateKeyError, empty, make, combine, read, diff, renderInitial, renderUpdate, hash, applyHashDelta, diffByKey, exports_instructions };

package/dist/chunks/location-mutation-8nn8kqcn.js

@@ -0,0 +1,25 @@
+// src/database/migration/20260603141458_session_input_inbox.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260603141458_session_input_inbox",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`session_input\` (
+          \`seq\` integer PRIMARY KEY AUTOINCREMENT,
+          \`id\` text NOT NULL UNIQUE,
+          \`session_id\` text NOT NULL,
+          \`prompt\` text NOT NULL,
+          \`delivery\` text NOT NULL,
+          \`promoted_seq\` integer,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`fk_session_input_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`CREATE INDEX \`session_input_session_pending_seq_idx\` ON \`session_input\` (\`session_id\`,\`promoted_seq\`,\`seq\`);`);
+    });
+  }
+};
+var _20260603141458_session_input_inbox_default = migration;
+
+export { _20260603141458_session_input_inbox_default };

package/dist/chunks/location-mutation-8sj3ajy5.js

@@ -0,0 +1,58 @@
+// src/database/migration/20260510033149_session_usage.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260510033149_session_usage",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`cost\` real DEFAULT 0 NOT NULL;`);
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`tokens_input\` integer DEFAULT 0 NOT NULL;`);
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`tokens_output\` integer DEFAULT 0 NOT NULL;`);
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`tokens_reasoning\` integer DEFAULT 0 NOT NULL;`);
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`tokens_cache_read\` integer DEFAULT 0 NOT NULL;`);
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`tokens_cache_write\` integer DEFAULT 0 NOT NULL;`);
+      yield* tx.run(`
+        UPDATE session
+        SET
+          cost = coalesce((
+            SELECT sum(coalesce(json_extract(message.data, '$.cost'), 0))
+            FROM message
+            WHERE message.session_id = session.id
+              AND json_extract(message.data, '$.role') = 'assistant'
+          ), 0),
+          tokens_input = coalesce((
+            SELECT sum(coalesce(json_extract(message.data, '$.tokens.input'), 0))
+            FROM message
+            WHERE message.session_id = session.id
+              AND json_extract(message.data, '$.role') = 'assistant'
+          ), 0),
+          tokens_output = coalesce((
+            SELECT sum(coalesce(json_extract(message.data, '$.tokens.output'), 0))
+            FROM message
+            WHERE message.session_id = session.id
+              AND json_extract(message.data, '$.role') = 'assistant'
+          ), 0),
+          tokens_reasoning = coalesce((
+            SELECT sum(coalesce(json_extract(message.data, '$.tokens.reasoning'), 0))
+            FROM message
+            WHERE message.session_id = session.id
+              AND json_extract(message.data, '$.role') = 'assistant'
+          ), 0),
+          tokens_cache_read = coalesce((
+            SELECT sum(coalesce(json_extract(message.data, '$.tokens.cache.read'), 0))
+            FROM message
+            WHERE message.session_id = session.id
+              AND json_extract(message.data, '$.role') = 'assistant'
+          ), 0),
+          tokens_cache_write = coalesce((
+            SELECT sum(coalesce(json_extract(message.data, '$.tokens.cache.write'), 0))
+            FROM message
+            WHERE message.session_id = session.id
+              AND json_extract(message.data, '$.role') = 'assistant'
+          ), 0)
+      `);
+    });
+  }
+};
+var _20260510033149_session_usage_default = migration;
+
+export { _20260510033149_session_usage_default };

package/dist/chunks/location-mutation-8v2yzmx6.js

@@ -0,0 +1,294 @@
+import {
+  exports_message
+} from "./location-mutation-25pxtba7.js";
+import {
+  SessionInboxTable,
+  SessionMessageTable
+} from "./location-mutation-9d2xhdr4.js";
+import {
+  SessionEvent
+} from "./location-mutation-a83yvq99.js";
+import {
+  exports_schema
+} from "./location-mutation-y8rs54ne.js";
+import {
+  exports_keyed_mutex
+} from "./location-mutation-0kvmztkf.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/session/inbox.ts
+var exports_inbox = {};
+__export(exports_inbox, {
+  steer: () => steer,
+  serialized: () => serialized,
+  queue: () => queue,
+  promote: () => promote,
+  projectDeliveryChanged: () => projectDeliveryChanged,
+  projectDelivered: () => projectDelivered,
+  projectCancelled: () => projectCancelled,
+  projectAdmitted: () => projectAdmitted,
+  nextSteer: () => nextSteer,
+  nextQueued: () => nextQueued,
+  nextPromotable: () => nextPromotable,
+  moveIDs: () => moveIDs,
+  list: () => list,
+  has: () => has,
+  find: () => find,
+  equivalent: () => equivalent,
+  cancel: () => cancel,
+  admitCompaction: () => admitCompaction,
+  admit: () => admit,
+  UserPayload: () => UserPayload,
+  User: () => User,
+  SyntheticPayload: () => SyntheticPayload,
+  Synthetic: () => Synthetic,
+  SessionInbox: () => exports_inbox,
+  MovePayload: () => MovePayload,
+  Move: () => Move,
+  LifecycleConflict: () => LifecycleConflict,
+  Item: () => Item,
+  Info: () => Info,
+  Delivery: () => Delivery,
+  CompactionPayload: () => CompactionPayload,
+  Compaction: () => Compaction
+});
+import { and, asc, eq, or } from "drizzle-orm";
+import { DateTime, Effect, Schema } from "effect";
+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(exports_message.Info);
+var inboxLocks = exports_keyed_mutex.makeUnsafe();
+var serialized = (sessionID, effect) => inboxLocks.withLock(sessionID)(effect);
+
+class LifecycleConflict extends Schema.TaggedErrorClass()("SessionInbox.LifecycleConflict", {
+  id: exports_message.ID
+}) {
+}
+var fromRow = (row) => {
+  const base = {
+    id: exports_message.ID.make(row.id),
+    sessionID: exports_schema.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* Effect.die(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* Effect.die(new LifecycleConflict({ id }));
+});
+var admit = Effect.fn("SessionInbox.admit")(function* (db, bus, request) {
+  const existing = yield* find(db, request.id);
+  if (existing !== undefined) {
+    if (existing.type === "compaction")
+      return yield* Effect.die(new LifecycleConflict({ id: request.id }));
+    return existing;
+  }
+  const promoted = yield* promotedFromMessage(db, request.sessionID, request.id, request.item.delivery);
+  if (promoted !== undefined)
+    return promoted;
+  return yield* bus.publish(SessionEvent.InboxEnqueued, {
+    inboxID: request.id,
+    sessionID: request.sessionID,
+    item: request.item
+  }).pipe(Effect.flatMap((event) => {
+    const base = {
+      id: request.id,
+      sessionID: request.sessionID,
+      timeCreated: DateTime.makeUnsafe(event.created)
+    };
+    return Effect.succeed(Info.make({ ...base, ...request.item }));
+  }), Effect.catchDefect((defect) => find(db, request.id).pipe(Effect.flatMap((stored) => stored?.type === request.item.type ? Effect.succeed(stored) : Effect.die(defect)))));
+});
+var admitCompaction = Effect.fn("SessionInbox.admitCompaction")(function* (db, bus, input) {
+  const admitted = yield* admit(db, bus, {
+    id: input.id,
+    sessionID: input.sessionID,
+    item: Item.make({ type: "compaction", payload: {}, delivery: input.delivery })
+  });
+  if (admitted.type === "compaction")
+    return admitted;
+  return yield* Effect.die(new LifecycleConflict({ id: input.id }));
+});
+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 nextQueued = Effect.fn("SessionInbox.nextQueued")(function* (db, sessionID) {
+  const row = 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);
+  return row ? fromRow(row) : undefined;
+});
+var nextSteer = Effect.fn("SessionInbox.nextSteer")(function* (db, sessionID) {
+  const row = yield* db.select().from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "steer"))).orderBy(asc(SessionInboxTable.enqueued_seq)).limit(1).get().pipe(Effect.orDie);
+  return row ? fromRow(row) : undefined;
+});
+var nextPromotable = Effect.fn("SessionInbox.nextPromotable")(function* (db, sessionID, promotable) {
+  return (yield* nextSteer(db, sessionID)) ?? (promotable === "input" ? yield* nextQueued(db, sessionID) : 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 === "any" ? undefined : 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 equivalent = (input, expected) => {
+  if (input.type !== expected.item.type || input.delivery !== expected.item.delivery || input.sessionID !== expected.sessionID)
+    return false;
+  if (input.type === "user" && expected.item.type === "user")
+    return JSON.stringify(encodeUser(input.payload)) === JSON.stringify(encodeUser(expected.item.payload));
+  if (input.type === "synthetic" && expected.item.type === "synthetic")
+    return JSON.stringify(encodeSynthetic(input.payload)) === JSON.stringify(encodeSynthetic(expected.item.payload));
+  if (input.type === "compaction" && expected.item.type === "compaction")
+    return true;
+  if (input.type === "move" && expected.item.type === "move")
+    return JSON.stringify(encodeMove(input.payload)) === JSON.stringify(encodeMove(expected.item.payload));
+  return false;
+};
+var publishMutation = (input, effect) => serialized(input.sessionID, effect).pipe(Effect.asVoid);
+var cancel = Effect.fn("SessionInbox.cancel")((bus, input) => publishMutation(input, bus.publish(SessionEvent.InboxCancelled, {
+  sessionID: input.sessionID,
+  inboxID: input.id
+})));
+var steer = Effect.fn("SessionInbox.steer")((bus, input) => publishMutation(input, bus.publish(SessionEvent.InboxDeliveryChanged, {
+  sessionID: input.sessionID,
+  inboxID: input.id,
+  delivery: "steer"
+})));
+var queue = Effect.fn("SessionInbox.queue")((bus, input) => publishMutation(input, bus.publish(SessionEvent.InboxDeliveryChanged, {
+  sessionID: input.sessionID,
+  inboxID: input.id,
+  delivery: "queue"
+})));
+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.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* db.select().from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "steer"))).orderBy(asc(SessionInboxTable.enqueued_seq)).all().pipe(Effect.orDie);
+    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* db.select().from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "steer"))).orderBy(asc(SessionInboxTable.enqueued_seq)).all().pipe(Effect.orDie);
+    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)));
+  }));
+});
+
+export { Compaction, CompactionPayload, Delivery, Info, Item, Move, MovePayload, Synthetic, SyntheticPayload, User, UserPayload, serialized, LifecycleConflict, find, admit, admitCompaction, projectAdmitted, projectDelivered, projectCancelled, projectDeliveryChanged, list, moveIDs, nextQueued, nextSteer, nextPromotable, has, equivalent, cancel, steer, queue, promote, exports_inbox };