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

package/dist/chunks/{instance-68yag814.js → kv-64z8z5x5.js}

@@ -1,42 +1,41 @@
 import {
-  __export,
-  __require
-} from "./instance-vpjkya7h.js";
+  __export
+} from "./kv-9rqn6x4v.js";
 
 // src/provider.ts
-var exports_provider = {};
-__export(exports_provider, {
-  AISDK_PREFIX: () => AISDK_PREFIX,
-  ID: () => ID,
-  Info: () => Info,
-  LoadError: () => LoadError,
-  Provider: () => exports_provider,
-  Request: () => Request,
-  Settings: () => Settings,
-  aisdk: () => aisdk,
-  isAISDK: () => isAISDK,
-  loadPackage: () => loadPackage,
-  mergeHeaders: () => mergeHeaders,
-  mergeOverlay: () => mergeOverlay,
-  packageName: () => packageName
+var exports_provider3 = {};
+__export(exports_provider3, {
+  AISDK_PREFIX: () => AISDK_PREFIX2,
+  ID: () => ID17,
+  Info: () => Info31,
+  LoadError: () => LoadError3,
+  Provider: () => exports_provider3,
+  Request: () => Request3,
+  Settings: () => Settings2,
+  aisdk: () => aisdk2,
+  isAISDK: () => isAISDK2,
+  loadPackage: () => loadPackage2,
+  mergeHeaders: () => mergeHeaders2,
+  mergeOverlay: () => mergeOverlay2,
+  packageName: () => packageName2
 });
 import { Effect, Schema } from "effect";
 import { Provider } from "@opencode-ai/schema/provider";
 import { isRecord } from "@opencode-ai/ai/utils/record";
 import { importModule, resolveModule } from "@opencode-ai/util/runtime-import";
-var ID = Provider.ID;
-var AISDK_PREFIX = "aisdk:";
-var isAISDK = (value) => value?.startsWith(AISDK_PREFIX) ?? false;
-var aisdk = (value) => isAISDK(value) ? value : `${AISDK_PREFIX}${value}`;
-function packageName(value) {
-  if (value === undefined || !isAISDK(value))
+var ID17 = Provider.ID;
+var AISDK_PREFIX2 = "aisdk:";
+var isAISDK2 = (value) => value?.startsWith(AISDK_PREFIX2) ?? false;
+var aisdk2 = (value) => isAISDK2(value) ? value : `${AISDK_PREFIX2}${value}`;
+function packageName2(value) {
+  if (value === undefined || !isAISDK2(value))
     return value;
-  return value.slice(AISDK_PREFIX.length);
+  return value.slice(AISDK_PREFIX2.length);
 }
 var JsonRecord = Schema.Record(Schema.String, Schema.Json);
 var decodeJsonRecord = Schema.decodeUnknownSync(JsonRecord);
 
-class LoadError extends Schema.TaggedError()("Provider.LoadError", {
+class LoadError3 extends Schema.TaggedError()("Provider.LoadError", {
   package: Schema.String,
   cause: Schema.Defect()
 }) {
@@ -81,7 +80,7 @@ var builtins = new Map([
   ["@opencode-ai/ai/providers/togetherai", () => import("@opencode-ai/ai/providers/togetherai")],
   ["@opencode-ai/ai/providers/xai", () => import("@opencode-ai/ai/providers/xai")]
 ]);
-var loadPackage = Effect.fn("Provider.loadPackage")(function* (specifier, npm) {
+var loadPackage2 = Effect.fn("Provider.loadPackage")(function* (specifier, npm) {
   const builtin = builtins.get(specifier);
   if (builtin)
     return yield* importPackage(specifier, specifier, builtin);
@@ -97,21 +96,21 @@ var loadPackage = Effect.fn("Provider.loadPackage")(function* (specifier, npm) {
   if (resolved)
     return yield* importPackage(specifier, resolved);
   if (!npm) {
-    return yield* new LoadError({
+    return yield* new LoadError3({
       package: specifier,
       cause: new Error(`Provider package ${specifier} is not installed`)
     });
   }
   const parts = specifier.split("/");
   const root = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0] ?? specifier;
-  const installed = yield* npm.add(root).pipe(Effect.mapError((cause) => new LoadError({ package: specifier, cause })));
+  const installed = yield* npm.add(root).pipe(Effect.mapError((cause) => new LoadError3({ package: specifier, cause })));
   const entrypoint = yield* Effect.try({
     try: () => resolveModule(specifier, installed.directory),
-    catch: (cause) => new LoadError({ package: specifier, cause })
+    catch: (cause) => new LoadError3({ package: specifier, cause })
   });
   return yield* importPackage(specifier, entrypoint);
 });
-function mergeOverlay(base, overlay) {
+function mergeOverlay2(base, overlay) {
   if (base === undefined)
     return overlay && decodeJsonRecord({ ...overlay });
   if (overlay === undefined)
@@ -122,11 +121,11 @@ function mergeOverlay(base, overlay) {
     if (right === undefined)
       return [key, left];
     if (isRecord(left) && isRecord(right))
-      return [key, mergeOverlay(left, right) ?? {}];
+      return [key, mergeOverlay2(left, right) ?? {}];
     return [key, right];
   })));
 }
-function mergeHeaders(base, overlay) {
+function mergeHeaders2(base, overlay) {
   if (base === undefined)
     return overlay && { ...overlay };
   if (overlay === undefined)
@@ -136,9 +135,9 @@ function mergeHeaders(base, overlay) {
     return result;
   }, new Map).values());
 }
-var Request = Provider.Request;
-var Settings = Provider.Settings;
-var Info = Provider.Info;
+var Request3 = Provider.Request;
+var Settings2 = Provider.Settings;
+var Info31 = Provider.Info;
 var importPackage = Effect.fn("Provider.importPackage")(function* (specifier, entrypoint, load = () => importModule(entrypoint)) {
   const module = yield* Effect.tryPromise({
     try: () => {
@@ -149,10 +148,10 @@ var importPackage = Effect.fn("Provider.importPackage")(function* (specifier, en
       packages.set(entrypoint, loaded);
       return loaded;
     },
-    catch: (cause) => new LoadError({ package: specifier, cause })
+    catch: (cause) => new LoadError3({ package: specifier, cause })
   });
   if (typeof module !== "object" || module === null || typeof module.model !== "function") {
-    return yield* new LoadError({
+    return yield* new LoadError3({
       package: specifier,
       cause: new Error(`Provider package ${specifier} does not export model(modelID, settings)`)
     });
@@ -160,4 +159,4 @@ var importPackage = Effect.fn("Provider.importPackage")(function* (specifier, en
   return module;
 });
 
-export { ID, AISDK_PREFIX, isAISDK, aisdk, packageName, LoadError, loadPackage, mergeOverlay, mergeHeaders, Request, Settings, Info, exports_provider };
+export { ID17, AISDK_PREFIX2, isAISDK2, aisdk2, packageName2, LoadError3, loadPackage2, mergeOverlay2, mergeHeaders2, Request3, Settings2, Info31, exports_provider3 };

package/dist/chunks/{instance-etbnsc4s.js → kv-6abnk40k.js}

@@ -1,22 +1,22 @@
 import {
-  collectBoundedResponseBody
-} from "./instance-jve7t217.js";
+  collectBoundedResponseBody2
+} from "./kv-3v8g72cx.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/plugin/websearch/mcp.ts
-var exports_mcp = {};
-__export(exports_mcp, {
-  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES,
-  WebSearchMcp: () => exports_mcp,
-  call: () => call,
-  parseResponse: () => parseResponse
+var exports_mcp2 = {};
+__export(exports_mcp2, {
+  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES3,
+  WebSearchMcp: () => exports_mcp2,
+  call: () => call2,
+  parseResponse: () => parseResponse2
 });
 import { Duration, Effect, Schema } from "effect";
 import { HttpClient, HttpClientRequest } from "effect/unstable/http";
-var MAX_RESPONSE_BYTES = 256 * 1024;
-var parseResponse = (body, result) => {
+var MAX_RESPONSE_BYTES3 = 256 * 1024;
+var parseResponse2 = (body, result) => {
   const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ result })));
   const parse = (payload) => {
     const trimmed = payload.trim();
@@ -39,7 +39,7 @@ var parseResponse = (body, result) => {
     }
   });
 };
-var call = (http, url, tool, schema, value, headers = {}) => Effect.gen(function* () {
+var call2 = (http, url, tool, schema, value, headers = {}) => Effect.gen(function* () {
   const request = yield* HttpClientRequest.post(url).pipe(HttpClientRequest.accept("application/json, text/event-stream"), HttpClientRequest.setHeaders(headers), HttpClientRequest.schemaBodyJson(Schema.Struct({
     jsonrpc: Schema.Literal("2.0"),
     id: Schema.Literal(1),
@@ -53,12 +53,12 @@ var call = (http, url, tool, schema, value, headers = {}) => Effect.gen(function
   }));
   return yield* Effect.gen(function* () {
     const response = yield* HttpClient.filterStatusOk(http).execute(request);
-    const body = yield* collectBoundedResponseBody(response, MAX_RESPONSE_BYTES, () => new Error(`${tool} response exceeded ${MAX_RESPONSE_BYTES} bytes`));
-    return yield* parseResponse(body.toString("utf8"), schema.output);
+    const body = yield* collectBoundedResponseBody2(response, MAX_RESPONSE_BYTES3, () => new Error(`${tool} response exceeded ${MAX_RESPONSE_BYTES3} bytes`));
+    return yield* parseResponse2(body.toString("utf8"), schema.output);
   }).pipe(Effect.timeoutOrElse({
     duration: Duration.seconds(25),
     orElse: () => Effect.fail(new Error(`${tool} request timed out`))
   }));
 });
 
-export { MAX_RESPONSE_BYTES, parseResponse, call, exports_mcp };
+export { MAX_RESPONSE_BYTES3, parseResponse2, call2, exports_mcp2 };

package/dist/chunks/kv-6c7eyv5g.js

@@ -0,0 +1,321 @@
+import {
+  Service80,
+  node84
+} from "./kv-3rps85z5.js";
+import {
+  makeUnsafe2
+} from "./kv-jwcy2c2z.js";
+import {
+  Service79,
+  node83
+} from "./kv-9j3fyze8.js";
+import {
+  SessionEvent2
+} from "./kv-mntxs535.js";
+import {
+  SessionMessage2
+} from "./kv-982e01ww.js";
+import {
+  SessionSchema2
+} from "./kv-cq35m6me.js";
+import {
+  SessionMessageTable2,
+  SessionInboxTable2
+} from "./kv-hrvm11jt.js";
+import {
+  __export
+} from "./kv-9rqn6x4v.js";
+
+// src/session/inbox.ts
+var exports_inbox = {};
+__export(exports_inbox, {
+  Compaction: () => Compaction2,
+  CompactionPayload: () => CompactionPayload2,
+  Delivery: () => Delivery2,
+  Info: () => Info4,
+  Item: () => Item2,
+  LifecycleConflict: () => LifecycleConflict2,
+  Move: () => Move2,
+  MovePayload: () => MovePayload2,
+  Service: () => Service25,
+  SessionInbox: () => exports_inbox,
+  Synthetic: () => Synthetic2,
+  SyntheticPayload: () => SyntheticPayload2,
+  User: () => User2,
+  UserPayload: () => UserPayload2,
+  find: () => find2,
+  has: () => has2,
+  layer: () => layer11,
+  list: () => list3,
+  make: () => make13,
+  moveIDs: () => moveIDs2,
+  nextPromotable: () => nextPromotable2,
+  node: () => node28,
+  projectAdmitted: () => projectAdmitted2,
+  projectCancelled: () => projectCancelled2,
+  projectDelivered: () => projectDelivered2,
+  projectDeliveryChanged: () => projectDeliveryChanged2,
+  promote: () => promote2,
+  serialized: () => serialized2
+});
+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 as Compaction2,
+  CompactionPayload as CompactionPayload2,
+  Delivery as Delivery2,
+  Info as Info4,
+  Item as Item2,
+  Move as Move2,
+  MovePayload as MovePayload2,
+  Synthetic as Synthetic2,
+  SyntheticPayload as SyntheticPayload2,
+  User as User2,
+  UserPayload as UserPayload2
+} from "@opencode-ai/schema/session-inbox";
+var decodeUser = Schema.decodeUnknownSync(UserPayload2);
+var encodeUser = Schema.encodeSync(UserPayload2);
+var decodeSynthetic = Schema.decodeUnknownSync(SyntheticPayload2);
+var encodeSynthetic = Schema.encodeSync(SyntheticPayload2);
+var decodeCompaction = Schema.decodeUnknownSync(CompactionPayload2);
+var encodeCompaction = Schema.encodeSync(CompactionPayload2);
+var decodeMove = Schema.decodeUnknownSync(MovePayload2);
+var encodeMove = Schema.encodeSync(MovePayload2);
+var decodeMessage = Schema.decodeUnknownSync(SessionMessage2.Info);
+var inboxLocks = makeUnsafe2();
+var serialized2 = (sessionID, effect) => inboxLocks.withLock(sessionID)(effect);
+
+class LifecycleConflict2 extends Schema.TaggedError()("SessionInbox.LifecycleConflict", {
+  id: SessionMessage2.ID
+}) {
+}
+function matches(stored, request) {
+  return stored.sessionID === request.sessionID && stored.type === request.type;
+}
+var fromRow = (row) => {
+  const base = {
+    id: SessionMessage2.ID.make(row.id),
+    sessionID: SessionSchema2.ID.make(row.session_id),
+    timeCreated: DateTime.makeUnsafe(row.time_created)
+  };
+  if (row.type === "compaction")
+    return Compaction2.make({
+      ...base,
+      type: "compaction",
+      payload: decodeCompaction(row.payload),
+      delivery: row.delivery
+    });
+  if (row.type === "move")
+    return Move2.make({ ...base, type: "move", payload: decodeMove(row.payload), delivery: row.delivery });
+  if (row.type === "user")
+    return User2.make({
+      ...base,
+      type: "user",
+      payload: decodeUser(row.payload),
+      delivery: row.delivery
+    });
+  if (row.type === "synthetic")
+    return Synthetic2.make({
+      ...base,
+      type: "synthetic",
+      payload: decodeSynthetic(row.payload),
+      delivery: row.delivery
+    });
+  throw new LifecycleConflict2({ id: base.id });
+};
+var find2 = Effect.fn("SessionInbox.find")(function* (db, id) {
+  const row = yield* db.select().from(SessionInboxTable2).where(eq(SessionInboxTable2.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(SessionMessageTable2).where(eq(SessionMessageTable2.id, id)).get().pipe(Effect.orDie);
+  if (row === undefined)
+    return;
+  if (row.session_id !== sessionID || row.type !== "user" && row.type !== "synthetic")
+    return yield* new LifecycleConflict2({ 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 User2.make({
+      ...base,
+      type: "user",
+      payload: decodeUser(message)
+    });
+  if (message.type === "synthetic")
+    return Synthetic2.make({
+      ...base,
+      type: "synthetic",
+      payload: decodeSynthetic(message)
+    });
+  return yield* new LifecycleConflict2({ id });
+});
+
+class Service25 extends Context.Service()("@opencode/SessionInbox") {
+}
+var make13 = Effect.fn("SessionInbox.make")(function* () {
+  const database = yield* Service80;
+  const db = database.db;
+  const bus = yield* Service79;
+  const reconcile = Effect.fn("SessionInbox.reconcile")(function* (request) {
+    const existing = (yield* find2(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 LifecycleConflict2({ 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(SessionEvent2.InboxEnqueued, {
+      inboxID: request.id,
+      sessionID: request.sessionID,
+      item: request.item
+    }).pipe(Effect.map((event) => Info4.make({
+      id: request.id,
+      sessionID: request.sessionID,
+      timeCreated: DateTime.makeUnsafe(event.created),
+      ...request.item
+    })), Effect.catchDefect((defect) => defect instanceof LifecycleConflict2 ? find2(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 LifecycleConflict2({ id: request.id });
+    return admitted;
+  });
+  const admitCompaction = Effect.fn("SessionInbox.admitCompaction")(function* (input) {
+    return yield* serialized2(input.sessionID, Effect.gen(function* () {
+      const exact = yield* find2(db, input.id);
+      if (exact) {
+        if (exact.type === "compaction" && exact.sessionID === input.sessionID)
+          return exact;
+        return yield* new LifecycleConflict2({ id: input.id });
+      }
+      if (yield* promotedFromMessage(db, input.sessionID, input.id, input.delivery))
+        return yield* new LifecycleConflict2({ id: input.id });
+      const pending = (yield* list3(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: Delivery2.make(input.delivery) }
+      });
+    }));
+  });
+  const cancel = Effect.fn("SessionInbox.cancel")((input) => publishMutation(input, bus.publish(SessionEvent2.InboxCancelled, {
+    sessionID: input.sessionID,
+    inboxID: input.id
+  })));
+  const steer = Effect.fn("SessionInbox.steer")((input) => publishMutation(input, bus.publish(SessionEvent2.InboxDeliveryChanged, {
+    sessionID: input.sessionID,
+    inboxID: input.id,
+    delivery: "steer"
+  })));
+  const queue = Effect.fn("SessionInbox.queue")((input) => publishMutation(input, bus.publish(SessionEvent2.InboxDeliveryChanged, {
+    sessionID: input.sessionID,
+    inboxID: input.id,
+    delivery: "queue"
+  })));
+  return {
+    list: (sessionID) => list3(db, sessionID),
+    reconcile,
+    admit,
+    admitCompaction,
+    cancel,
+    steer,
+    queue
+  };
+});
+var layer11 = Layer.effect(Service25, make13());
+var node28 = makeGlobalNode({ service: Service25, layer: layer11, deps: [node84, node83] });
+var projectAdmitted2 = Effect.fn("SessionInbox.projectAdmitted")(function* (db, request) {
+  const message = yield* db.select({ id: SessionMessageTable2.id }).from(SessionMessageTable2).where(eq(SessionMessageTable2.id, request.id)).get().pipe(Effect.orDie);
+  if (message !== undefined)
+    return yield* Effect.die(new LifecycleConflict2({ id: request.id }));
+  const stored = yield* db.insert(SessionInboxTable2).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: SessionInboxTable2.id }).get().pipe(Effect.orDie);
+  if (!stored)
+    return yield* Effect.die(new LifecycleConflict2({ id: request.id }));
+});
+var projectDelivered2 = Effect.fn("SessionInbox.projectDelivered")(function* (db, input) {
+  const deleted = yield* db.delete(SessionInboxTable2).where(and(eq(SessionInboxTable2.id, input.id), eq(SessionInboxTable2.session_id, input.sessionID))).returning().get().pipe(Effect.orDie);
+  if (!deleted)
+    return yield* Effect.die(new LifecycleConflict2({ id: input.id }));
+  return fromRow(deleted);
+});
+var projectCancelled2 = Effect.fn("SessionInbox.projectCancelled")(function* (db, input) {
+  const deleted = yield* db.delete(SessionInboxTable2).where(and(eq(SessionInboxTable2.id, input.id), eq(SessionInboxTable2.session_id, input.sessionID), or(eq(SessionInboxTable2.delivery, "queue"), eq(SessionInboxTable2.delivery, "steer")))).returning({ id: SessionInboxTable2.id }).get().pipe(Effect.orDie);
+  if (!deleted)
+    return yield* Effect.die(new LifecycleConflict2({ id: input.id }));
+});
+var projectDelivery = Effect.fn("SessionInbox.projectDelivery")(function* (db, input) {
+  const updated = yield* db.update(SessionInboxTable2).set({ delivery: input.to }).where(and(eq(SessionInboxTable2.id, input.id), eq(SessionInboxTable2.session_id, input.sessionID), eq(SessionInboxTable2.delivery, input.from))).returning({ id: SessionInboxTable2.id }).get().pipe(Effect.orDie);
+  if (!updated)
+    return yield* Effect.die(new LifecycleConflict2({ id: input.id }));
+});
+var projectDeliveryChanged2 = Effect.fn("SessionInbox.projectDeliveryChanged")((db, input) => projectDelivery(db, {
+  ...input,
+  from: input.delivery === "steer" ? "queue" : "steer",
+  to: input.delivery
+}));
+var list3 = Effect.fn("SessionInbox.list")(function* (db, sessionID) {
+  const rows = yield* db.select().from(SessionInboxTable2).where(eq(SessionInboxTable2.session_id, sessionID)).orderBy(asc(SessionInboxTable2.enqueued_seq)).all().pipe(Effect.orDie);
+  return rows.map(fromRow);
+});
+var moveIDs2 = Effect.fn("SessionInbox.moveIDs")(function* (db, sessionID) {
+  return yield* db.select({ id: SessionInboxTable2.id }).from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.type, "move"))).orderBy(asc(SessionInboxTable2.enqueued_seq)).all().pipe(Effect.orDie);
+});
+var nextPromotable2 = Effect.fn("SessionInbox.nextPromotable")(function* (db, sessionID, promotable) {
+  const next = (delivery) => db.select().from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.delivery, delivery))).orderBy(asc(SessionInboxTable2.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 has2 = Effect.fn("SessionInbox.has")(function* (db, sessionID, scope) {
+  const row = yield* db.select({ id: SessionInboxTable2.id }).from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), scope === "input" ? or(eq(SessionInboxTable2.delivery, "steer"), eq(SessionInboxTable2.delivery, "queue")) : eq(SessionInboxTable2.delivery, scope))).limit(1).get().pipe(Effect.orDie);
+  return row !== undefined;
+});
+var publishMutation = (input, effect) => serialized2(input.sessionID, effect).pipe(Effect.asVoid, Effect.catchDefect((defect) => defect instanceof LifecycleConflict2 ? 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 LifecycleConflict2({ id: entry.id }));
+    return bus.publish(SessionEvent2.InboxDelivered, {
+      sessionID,
+      inboxID: entry.id
+    }).pipe(Effect.catchDefect((defect) => defect instanceof LifecycleConflict2 ? 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 promote2 = Effect.fn("SessionInbox.promote")(function* (db, bus, sessionID, scope) {
+  return yield* serialized2(sessionID, Effect.gen(function* () {
+    const steers = yield* pendingSteers(db, sessionID);
+    if (steers.length > 0 || scope === "steer") {
+      const control = steers.findIndex((row) => row.type === "compaction" || row.type === "move");
+      return yield* publish(db, bus, sessionID, control === -1 ? steers : steers.slice(0, control));
+    }
+    const queued = yield* db.select().from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.delivery, "queue"))).orderBy(asc(SessionInboxTable2.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(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.delivery, "steer"))).orderBy(asc(SessionInboxTable2.enqueued_seq)).all().pipe(Effect.orDie);
+
+export { Compaction2, CompactionPayload2, Delivery2, Info4, Item2, Move2, MovePayload2, Synthetic2, SyntheticPayload2, User2, UserPayload2, serialized2, LifecycleConflict2, find2, Service25, make13, layer11, node28, projectAdmitted2, projectDelivered2, projectCancelled2, projectDeliveryChanged2, list3, moveIDs2, nextPromotable2, has2, promote2, exports_inbox };