@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-vynn1k31.js

@@ -0,0 +1,257 @@
+import {
+  exports_id
+} from "./permission-tcn24h1d.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/job.ts
+var exports_job = {};
+__export(exports_job, {
+  node: () => node,
+  make: () => make,
+  Service: () => Service,
+  Job: () => exports_job
+});
+import { Cause, Clock, Context, Deferred, Effect, Exit, Layer, Scope, SynchronizedRef } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+class Service extends Context.Service()("@opencode/Job") {
+}
+function snapshot(job) {
+  return {
+    ...job.info,
+    ...job.info.metadata ? { metadata: { ...job.info.metadata } } : {}
+  };
+}
+function errorText(error) {
+  if (error instanceof Error)
+    return error.message;
+  return String(error);
+}
+function incrementSession(input, sessionID) {
+  return new Map(input).set(sessionID, (input.get(sessionID) ?? 0) + 1);
+}
+function decrementSession(input, sessionID) {
+  const count = input.get(sessionID);
+  if (count === undefined)
+    return input;
+  const next = new Map(input);
+  if (count <= 1)
+    next.delete(sessionID);
+  else
+    next.set(sessionID, count - 1);
+  return next;
+}
+var make = Effect.gen(function* () {
+  const state = {
+    jobs: yield* SynchronizedRef.make(new Map),
+    scope: yield* Scope.Scope
+  };
+  const settle = Effect.fn("Job.settle")(function* (id, token, exit) {
+    const completed_at = yield* Clock.currentTimeMillis;
+    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+      const job = jobs.get(id);
+      if (!job)
+        return [{}, jobs];
+      if (job.token !== token)
+        return [{}, jobs];
+      if (job.info.status !== "running")
+        return [{ info: snapshot(job) }, jobs];
+      const status = Exit.isSuccess(exit) ? "completed" : Cause.hasInterruptsOnly(exit.cause) ? "cancelled" : "error";
+      const next = {
+        ...job,
+        blockingSessions: new Map,
+        info: {
+          ...job.info,
+          status,
+          completed_at,
+          ...Exit.isSuccess(exit) ? { output: exit.value } : {},
+          ...Exit.isFailure(exit) ? { error: errorText(Cause.squash(exit.cause)) } : {}
+        }
+      };
+      return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)];
+    });
+    if (result.info && result.done)
+      yield* Deferred.succeed(result.done, result.info).pipe(Effect.ignore);
+    if (result.scope) {
+      yield* Scope.close(result.scope, Exit.void).pipe(Effect.forkIn(state.scope, { startImmediately: true }));
+    }
+    return result.info;
+  });
+  const fork = Effect.fn("Job.fork")(function* (scope, id, token, run) {
+    return yield* run.pipe(Effect.matchCauseEffect({
+      onSuccess: (output) => settle(id, token, Exit.succeed(output)),
+      onFailure: (cause) => settle(id, token, Exit.failCause(cause))
+    }), Effect.asVoid, Effect.forkIn(scope, { startImmediately: true }));
+  });
+  const list = Effect.fn("Job.list")(function* () {
+    return Array.from((yield* SynchronizedRef.get(state.jobs)).values()).map(snapshot).toSorted((a, b) => a.started_at - b.started_at);
+  });
+  const get = Effect.fn("Job.get")(function* (id) {
+    const job = (yield* SynchronizedRef.get(state.jobs)).get(id);
+    if (!job)
+      return;
+    return snapshot(job);
+  });
+  const start = Effect.fn("Job.start")(function* (input) {
+    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+      const id = input.id ?? exports_id.ascending("job");
+      const started_at = yield* Clock.currentTimeMillis;
+      const done = yield* Deferred.make();
+      const backgrounded = yield* Deferred.make();
+      const result = yield* SynchronizedRef.modifyEffect(state.jobs, Effect.fnUntraced(function* (jobs) {
+        const existing = jobs.get(id);
+        if (existing?.info.status === "running") {
+          return [{ info: snapshot(existing) }, jobs];
+        }
+        const scope = yield* Scope.fork(state.scope, "parallel");
+        const token = {};
+        const job = {
+          info: {
+            id,
+            type: input.type,
+            title: input.title,
+            status: "running",
+            started_at,
+            metadata: input.metadata
+          },
+          done,
+          backgrounded,
+          scope,
+          token,
+          blockingSessions: new Map,
+          isBackgrounded: false
+        };
+        return [{ info: snapshot(job), scope, token }, new Map(jobs).set(id, job)];
+      }));
+      if ("scope" in result)
+        yield* fork(result.scope, id, result.token, restore(input.run));
+      return result.info;
+    }));
+  });
+  const wait = Effect.fn("Job.wait")(function* (input) {
+    const job = (yield* SynchronizedRef.get(state.jobs)).get(input.id);
+    if (!job)
+      return { timedOut: false };
+    if (job.info.status !== "running")
+      return { info: snapshot(job), timedOut: false };
+    if (input.timeout === undefined)
+      return { info: yield* Deferred.await(job.done), timedOut: false };
+    if (input.timeout <= 0)
+      return { info: snapshot(job), timedOut: true };
+    const info = yield* Deferred.await(job.done).pipe(Effect.timeoutOption(input.timeout));
+    if (info._tag === "Some")
+      return { info: info.value, timedOut: false };
+    return { info: snapshot(job), timedOut: true };
+  });
+  const removeBlock = Effect.fn("Job.removeBlock")(function* (input) {
+    yield* SynchronizedRef.update(state.jobs, (jobs) => {
+      const job = jobs.get(input.id);
+      if (!job || job.info.status !== "running" || job.isBackgrounded)
+        return jobs;
+      return new Map(jobs).set(input.id, {
+        ...job,
+        blockingSessions: decrementSession(job.blockingSessions, input.sessionID)
+      });
+    });
+  });
+  const block = Effect.fn("Job.block")(function* (input) {
+    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+      const job = jobs.get(input.id);
+      if (!job)
+        return [{ type: "missing" }, jobs];
+      if (job.info.status !== "running")
+        return [{ type: "finished", info: snapshot(job) }, jobs];
+      if (job.isBackgrounded)
+        return [{ type: "backgrounded", info: snapshot(job) }, jobs];
+      return [
+        { type: "wait", wait: { done: job.done, backgrounded: job.backgrounded } },
+        new Map(jobs).set(input.id, {
+          ...job,
+          blockingSessions: incrementSession(job.blockingSessions, input.sessionID)
+        })
+      ];
+    });
+    if (result.type === "missing")
+      return;
+    if (result.type === "finished")
+      return { type: "finished", info: result.info };
+    if (result.type === "backgrounded")
+      return { type: "backgrounded", info: result.info };
+    return yield* Effect.raceFirst(Deferred.await(result.wait.done).pipe(Effect.map((info) => ({ type: "finished", info }))), Deferred.await(result.wait.backgrounded).pipe(Effect.map((info) => ({ type: "backgrounded", info })))).pipe(Effect.ensuring(removeBlock(input)));
+  });
+  const background = Effect.fn("Job.background")(function* (id) {
+    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+      const job = jobs.get(id);
+      if (!job || job.info.status !== "running")
+        return [{}, jobs];
+      if (job.isBackgrounded)
+        return [{ info: snapshot(job) }, jobs];
+      const next = {
+        ...job,
+        isBackgrounded: true,
+        blockingSessions: new Map
+      };
+      return [{ info: snapshot(next), backgrounded: job.backgrounded }, new Map(jobs).set(id, next)];
+    });
+    if (result.info && result.backgrounded)
+      yield* Deferred.succeed(result.backgrounded, result.info).pipe(Effect.ignore);
+    return result.info;
+  });
+  const backgroundAll = Effect.fn("Job.backgroundAll")(function* (input) {
+    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+      const results = [];
+      const next = new Map(jobs);
+      for (const [id, job] of jobs) {
+        if (job.info.status !== "running")
+          continue;
+        if (job.isBackgrounded)
+          continue;
+        if (input.type !== undefined && job.info.type !== input.type)
+          continue;
+        if (!job.blockingSessions.has(input.sessionID))
+          continue;
+        const updated = {
+          ...job,
+          isBackgrounded: true,
+          blockingSessions: new Map
+        };
+        results.push({ info: snapshot(updated), backgrounded: job.backgrounded });
+        next.set(id, updated);
+      }
+      return [results, next];
+    });
+    yield* Effect.forEach(result, (item) => item.info && item.backgrounded ? Deferred.succeed(item.backgrounded, item.info) : Effect.void, { discard: true });
+    return result.flatMap((item) => item.info ? [item.info] : []);
+  });
+  const cancel = Effect.fn("Job.cancel")(function* (id) {
+    const completed_at = yield* Clock.currentTimeMillis;
+    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+      const job = jobs.get(id);
+      if (!job)
+        return [{}, jobs];
+      if (job.info.status !== "running")
+        return [{ info: snapshot(job) }, jobs];
+      const next = {
+        ...job,
+        blockingSessions: new Map,
+        info: {
+          ...job.info,
+          status: "cancelled",
+          completed_at
+        }
+      };
+      return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)];
+    });
+    if (result.info && result.done)
+      yield* Deferred.succeed(result.done, result.info).pipe(Effect.ignore);
+    if (result.scope)
+      yield* Scope.close(result.scope, Exit.void);
+    return result.info;
+  });
+  return Service.of({ list, get, start, wait, block, background, backgroundAll, cancel });
+});
+var layer = Layer.effect(Service, make);
+var node = makeGlobalNode({ service: Service, layer, deps: [] });
+
+export { Service, make, node, exports_job };

package/dist/chunks/permission-vz49gck1.js

@@ -0,0 +1,309 @@
+import {
+  exports_message
+} from "./permission-25pxtba7.js";
+import {
+  SessionMessageTable,
+  SessionPendingTable
+} from "./permission-zvvp2xr4.js";
+import {
+  SessionEvent
+} from "./permission-a83yvq99.js";
+import {
+  exports_schema
+} from "./permission-y8rs54ne.js";
+import {
+  exports_keyed_mutex
+} from "./permission-0kvmztkf.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/pending.ts
+var exports_pending = {};
+__export(exports_pending, {
+  steer: () => steer,
+  settleCompaction: () => settleCompaction,
+  queue: () => queue,
+  promote: () => promote,
+  projectSteered: () => projectSteered,
+  projectQueued: () => projectQueued,
+  projectPromoted: () => projectPromoted,
+  projectCompactionAdmitted: () => projectCompactionAdmitted,
+  projectCancelled: () => projectCancelled,
+  projectAdmitted: () => projectAdmitted,
+  list: () => list,
+  has: () => has,
+  find: () => find,
+  equivalent: () => equivalent,
+  compaction: () => compaction,
+  cancel: () => cancel,
+  admitCompaction: () => admitCompaction,
+  admit: () => admit,
+  UserData: () => UserData,
+  User: () => User,
+  SyntheticData: () => SyntheticData,
+  Synthetic: () => Synthetic,
+  SessionPending: () => exports_pending,
+  Message: () => Message,
+  LifecycleConflict: () => LifecycleConflict,
+  Info: () => Info,
+  Delivery: () => Delivery,
+  Compaction: () => Compaction
+});
+import { and, asc, eq, or } from "drizzle-orm";
+import { DateTime, Effect, Schema } from "effect";
+import {
+  Compaction,
+  Delivery,
+  Info,
+  Message,
+  Synthetic,
+  SyntheticData,
+  User,
+  UserData
+} from "@opencode-ai/schema/session-pending";
+var decodeUser = Schema.decodeUnknownSync(UserData);
+var encodeUser = Schema.encodeSync(UserData);
+var decodeSynthetic = Schema.decodeUnknownSync(SyntheticData);
+var encodeSynthetic = Schema.encodeSync(SyntheticData);
+var decodeMessage = Schema.decodeUnknownSync(exports_message.Info);
+var inboxLocks = exports_keyed_mutex.makeUnsafe();
+
+class LifecycleConflict extends Schema.TaggedErrorClass()("SessionPending.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" });
+  if (!row.delivery)
+    throw new LifecycleConflict({ id: base.id });
+  if (row.type === "user")
+    return User.make({
+      ...base,
+      type: "user",
+      data: decodeUser(row.data),
+      delivery: row.delivery
+    });
+  if (row.type === "synthetic")
+    return Synthetic.make({
+      ...base,
+      type: "synthetic",
+      data: decodeSynthetic(row.data),
+      delivery: row.delivery
+    });
+  throw new LifecycleConflict({ id: base.id });
+};
+var find = Effect.fn("SessionPending.find")(function* (db, id) {
+  const row = yield* db.select().from(SessionPendingTable).where(eq(SessionPendingTable.id, id)).get().pipe(Effect.orDie);
+  return row === undefined ? undefined : fromRow(row);
+});
+var compaction = Effect.fn("SessionPending.compaction")(function* (db, sessionID) {
+  const row = yield* db.select().from(SessionPendingTable).where(and(eq(SessionPendingTable.session_id, sessionID), eq(SessionPendingTable.type, "compaction"))).orderBy(asc(SessionPendingTable.admitted_seq)).limit(1).get().pipe(Effect.orDie);
+  if (!row)
+    return;
+  const entry = fromRow(row);
+  return entry.type === "compaction" ? entry : undefined;
+});
+var promotedFromMessage = Effect.fn("SessionPending.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",
+      data: decodeUser(message)
+    });
+  if (message.type === "synthetic")
+    return Synthetic.make({
+      ...base,
+      type: "synthetic",
+      data: decodeSynthetic(message)
+    });
+  return yield* Effect.die(new LifecycleConflict({ id }));
+});
+var admit = Effect.fn("SessionPending.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.input.delivery);
+  if (promoted !== undefined)
+    return promoted;
+  return yield* bus.publish(SessionEvent.InputAdmitted, {
+    inputID: request.id,
+    sessionID: request.sessionID,
+    input: request.input
+  }).pipe(Effect.flatMap((event) => {
+    const base = {
+      id: request.id,
+      sessionID: request.sessionID,
+      timeCreated: event.created
+    };
+    return Effect.succeed(request.input.type === "user" ? User.make({ ...base, ...request.input }) : Synthetic.make({ ...base, ...request.input }));
+  }), Effect.catchDefect((defect) => find(db, request.id).pipe(Effect.flatMap((stored) => stored?.type === request.input.type ? Effect.succeed(stored) : Effect.die(defect)))));
+});
+var admitCompaction = Effect.fn("SessionPending.admitCompaction")(function* (db, bus, input) {
+  return yield* inboxLocks.withLock(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* Effect.die(new LifecycleConflict({ id: input.id }));
+    }
+    const pending = yield* compaction(db, input.sessionID);
+    if (pending)
+      return pending;
+    return yield* bus.publish(SessionEvent.Compaction.Admitted, {
+      inputID: input.id,
+      sessionID: input.sessionID
+    }).pipe(Effect.flatMap((event) => {
+      if (event.durable === undefined)
+        return Effect.die(new Error("Compaction admission event is missing aggregate sequence"));
+      return compaction(db, input.sessionID).pipe(Effect.flatMap((stored) => stored ? Effect.succeed(stored) : Effect.die(new LifecycleConflict({ id: input.id }))));
+    }), Effect.catchDefect((defect) => compaction(db, input.sessionID).pipe(Effect.flatMap((stored) => stored ? Effect.succeed(stored) : Effect.die(defect)))));
+  }));
+});
+var projectAdmitted = Effect.fn("SessionPending.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(SessionPendingTable).values({
+    id: request.id,
+    session_id: request.sessionID,
+    type: request.input.type,
+    data: request.input.type === "user" ? encodeUser(request.input.data) : encodeSynthetic(request.input.data),
+    delivery: request.input.delivery,
+    admitted_seq: request.admittedSeq,
+    time_created: DateTime.toEpochMillis(request.timeCreated)
+  }).onConflictDoNothing().returning({ id: SessionPendingTable.id }).get().pipe(Effect.orDie);
+  if (!stored)
+    return yield* Effect.die(new LifecycleConflict({ id: request.id }));
+});
+var projectCompactionAdmitted = Effect.fn("SessionPending.projectCompactionAdmitted")(function* (db, input) {
+  const message = yield* db.select({ id: SessionMessageTable.id }).from(SessionMessageTable).where(eq(SessionMessageTable.id, input.id)).get().pipe(Effect.orDie);
+  if (message !== undefined)
+    return yield* Effect.die(new LifecycleConflict({ id: input.id }));
+  const stored = yield* db.insert(SessionPendingTable).values({
+    id: input.id,
+    session_id: input.sessionID,
+    type: "compaction",
+    data: {},
+    admitted_seq: input.admittedSeq,
+    time_created: DateTime.toEpochMillis(input.timeCreated)
+  }).onConflictDoNothing().returning().get().pipe(Effect.orDie);
+  if (stored) {
+    const entry = fromRow(stored);
+    return entry.type === "compaction" ? entry : yield* Effect.die(new LifecycleConflict({ id: entry.id }));
+  }
+  const pending = yield* compaction(db, input.sessionID);
+  if (pending)
+    return pending;
+  return yield* Effect.die(new LifecycleConflict({ id: input.id }));
+});
+var projectPromoted = Effect.fn("SessionPending.projectPromoted")(function* (db, input) {
+  if (yield* compaction(db, input.sessionID))
+    return yield* Effect.die(new LifecycleConflict({ id: input.id }));
+  const deleted = yield* db.delete(SessionPendingTable).where(and(eq(SessionPendingTable.id, input.id), eq(SessionPendingTable.session_id, input.sessionID))).returning().get().pipe(Effect.orDie);
+  if (!deleted)
+    return yield* Effect.die(new LifecycleConflict({ id: input.id }));
+  const stored = fromRow(deleted);
+  if (stored.type === "compaction")
+    return yield* Effect.die(new LifecycleConflict({ id: input.id }));
+  return stored;
+});
+var projectCancelled = Effect.fn("SessionPending.projectCancelled")(function* (db, input) {
+  const deleted = yield* db.delete(SessionPendingTable).where(and(eq(SessionPendingTable.id, input.id), eq(SessionPendingTable.session_id, input.sessionID), or(eq(SessionPendingTable.delivery, "queue"), eq(SessionPendingTable.delivery, "steer")))).returning({ id: SessionPendingTable.id }).get().pipe(Effect.orDie);
+  if (!deleted)
+    return yield* Effect.die(new LifecycleConflict({ id: input.id }));
+});
+var projectDelivery = Effect.fn("SessionPending.projectDelivery")(function* (db, input) {
+  const updated = yield* db.update(SessionPendingTable).set({ delivery: input.to }).where(and(eq(SessionPendingTable.id, input.id), eq(SessionPendingTable.session_id, input.sessionID), eq(SessionPendingTable.delivery, input.from))).returning({ id: SessionPendingTable.id }).get().pipe(Effect.orDie);
+  if (!updated)
+    return yield* Effect.die(new LifecycleConflict({ id: input.id }));
+});
+var projectSteered = Effect.fn("SessionPending.projectSteered")((db, input) => projectDelivery(db, { ...input, from: "queue", to: "steer" }));
+var projectQueued = Effect.fn("SessionPending.projectQueued")((db, input) => projectDelivery(db, { ...input, from: "steer", to: "queue" }));
+var settleCompaction = Effect.fn("SessionPending.settleCompaction")(function* (db, input) {
+  const deleted = yield* db.delete(SessionPendingTable).where(and(eq(SessionPendingTable.session_id, input.sessionID), eq(SessionPendingTable.type, "compaction"))).returning().get().pipe(Effect.orDie);
+  if (deleted) {
+    const stored = fromRow(deleted);
+    return stored.type === "compaction" ? stored : yield* Effect.die(new LifecycleConflict({ id: stored.id }));
+  }
+  return;
+});
+var list = Effect.fn("SessionPending.list")(function* (db, sessionID) {
+  const rows = yield* db.select().from(SessionPendingTable).where(eq(SessionPendingTable.session_id, sessionID)).orderBy(asc(SessionPendingTable.admitted_seq)).all().pipe(Effect.orDie);
+  return rows.map(fromRow);
+});
+var has = Effect.fn("SessionPending.has")(function* (db, sessionID, scope) {
+  if (scope !== "any" && (yield* compaction(db, sessionID)))
+    return false;
+  const row = yield* db.select({ id: SessionPendingTable.id }).from(SessionPendingTable).where(and(eq(SessionPendingTable.session_id, sessionID), scope === "any" ? undefined : scope === "input" ? or(eq(SessionPendingTable.delivery, "steer"), eq(SessionPendingTable.delivery, "queue")) : eq(SessionPendingTable.delivery, scope))).limit(1).get().pipe(Effect.orDie);
+  return row !== undefined;
+});
+var equivalent = (input, expected) => {
+  if (input.type !== expected.input.type || input.delivery !== expected.input.delivery || input.sessionID !== expected.sessionID)
+    return false;
+  if (input.type === "user" && expected.input.type === "user")
+    return JSON.stringify(encodeUser(input.data)) === JSON.stringify(encodeUser(expected.input.data));
+  if (input.type === "synthetic" && expected.input.type === "synthetic")
+    return JSON.stringify(encodeSynthetic(input.data)) === JSON.stringify(encodeSynthetic(expected.input.data));
+  return false;
+};
+var publishMutation = (input, effect) => inboxLocks.withLock(input.sessionID)(effect).pipe(Effect.asVoid);
+var cancel = Effect.fn("SessionPending.cancel")((bus, input) => publishMutation(input, bus.publish(SessionEvent.InputCancelled, {
+  sessionID: input.sessionID,
+  inputID: input.id
+})));
+var steer = Effect.fn("SessionPending.steer")((bus, input) => publishMutation(input, bus.publish(SessionEvent.InputSteered, {
+  sessionID: input.sessionID,
+  inputID: input.id
+})));
+var queue = Effect.fn("SessionPending.queue")((bus, input) => publishMutation(input, bus.publish(SessionEvent.InputQueued, {
+  sessionID: input.sessionID,
+  inputID: input.id
+})));
+var publish = Effect.fn("SessionPending.publish")(function* (db, bus, sessionID, rows) {
+  if (yield* compaction(db, sessionID))
+    return 0;
+  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.InputPromoted, {
+      sessionID,
+      inputID: 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("SessionPending.promote")(function* (db, bus, sessionID, scope) {
+  return yield* inboxLocks.withLock(sessionID)(Effect.gen(function* () {
+    if (yield* compaction(db, sessionID))
+      return 0;
+    const steers = yield* db.select().from(SessionPendingTable).where(and(eq(SessionPendingTable.session_id, sessionID), eq(SessionPendingTable.delivery, "steer"))).orderBy(asc(SessionPendingTable.admitted_seq)).all().pipe(Effect.orDie);
+    if (steers.length > 0 || scope === "steer")
+      return yield* publish(db, bus, sessionID, steers);
+    const queued = yield* db.select().from(SessionPendingTable).where(and(eq(SessionPendingTable.session_id, sessionID), eq(SessionPendingTable.delivery, "queue"))).orderBy(asc(SessionPendingTable.admitted_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(SessionPendingTable).where(and(eq(SessionPendingTable.session_id, sessionID), eq(SessionPendingTable.delivery, "steer"))).orderBy(asc(SessionPendingTable.admitted_seq)).all().pipe(Effect.orDie);
+    return promoted + (yield* publish(db, bus, sessionID, arrivedSteers));
+  }));
+});
+
+export { Compaction, Delivery, Info, Message, Synthetic, SyntheticData, User, UserData, LifecycleConflict, find, compaction, admit, admitCompaction, projectAdmitted, projectCompactionAdmitted, projectPromoted, projectCancelled, projectSteered, projectQueued, settleCompaction, list, has, equivalent, cancel, steer, queue, promote, exports_pending };

package/dist/chunks/permission-vz89hfgr.js

@@ -0,0 +1,116 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/vcs/patch.ts
+var exports_patch = {};
+__export(exports_patch, {
+  splitGitPatch: () => splitGitPatch,
+  fileFromPatchChunk: () => fileFromPatchChunk,
+  emptyPatch: () => emptyPatch,
+  deletePatch: () => deletePatch,
+  countPatch: () => countPatch,
+  chunksByFile: () => chunksByFile,
+  addPatch: () => addPatch,
+  VcsPatch: () => exports_patch,
+  PATCH_CONTEXT_LINES: () => PATCH_CONTEXT_LINES,
+  MAX_TOTAL_PATCH_BYTES: () => MAX_TOTAL_PATCH_BYTES,
+  MAX_PATCH_BYTES: () => MAX_PATCH_BYTES
+});
+import { formatPatch, structuredPatch } from "diff";
+var PATCH_CONTEXT_LINES = 2147483647;
+var MAX_PATCH_BYTES = 1e7;
+var MAX_TOTAL_PATCH_BYTES = 1e7;
+var emptyPatch = (file) => formatPatch(structuredPatch(file, file, "", "", "", "", { context: 0 }));
+var addPatch = (file, content) => formatPatch(structuredPatch(file, file, "", content, "", "", { context: 0 }));
+var deletePatch = (file, content) => formatPatch(structuredPatch(file, file, content, "", "", "", { context: 0 }));
+var countPatch = (patch) => {
+  let additions = 0;
+  let deletions = 0;
+  for (const line of patch.split(`
+`)) {
+    if (line.startsWith("+") && !line.startsWith("+++"))
+      additions++;
+    else if (line.startsWith("-") && !line.startsWith("---"))
+      deletions++;
+  }
+  return { additions, deletions };
+};
+var parseQuotedPath = (value) => {
+  let out = "";
+  for (let idx = 1;idx < value.length; idx++) {
+    const char = value[idx];
+    if (char === '"')
+      return { value: out, end: idx + 1 };
+    if (char !== "\\") {
+      out += char;
+      continue;
+    }
+    const next = value[++idx];
+    if (next === "t")
+      out += "\t";
+    else if (next === "n")
+      out += `
+`;
+    else if (next === "r")
+      out += "\r";
+    else if (next === '"' || next === "\\")
+      out += next;
+    else
+      out += next ?? "";
+  }
+};
+var parsePathToken = (value) => {
+  if (!value.startsWith('"'))
+    return value.split("\t")[0];
+  return parseQuotedPath(value)?.value ?? value;
+};
+var fileFromDiffPath = (value) => {
+  if (!value || value === "/dev/null")
+    return;
+  const file = parsePathToken(value);
+  if (file.startsWith("a/") || file.startsWith("b/"))
+    return file.slice(2);
+  return file;
+};
+var fileFromGitHeader = (header) => {
+  if (header.startsWith('"')) {
+    const first = parseQuotedPath(header);
+    const second = first ? header.slice(first.end).trimStart() : undefined;
+    if (!second)
+      return;
+    if (!second.startsWith('"'))
+      return fileFromDiffPath(second);
+    return fileFromDiffPath(parseQuotedPath(second)?.value);
+  }
+  const separator = header.indexOf(" b/");
+  if (separator === -1)
+    return;
+  return fileFromDiffPath(header.slice(separator + 1));
+};
+var fileFromPatchChunk = (chunk) => {
+  const next = /^\+\+\+ (.+)$/m.exec(chunk)?.[1];
+  const before = /^--- (.+)$/m.exec(chunk)?.[1];
+  const file = fileFromDiffPath(next) ?? fileFromDiffPath(before);
+  if (file)
+    return file;
+  const header = /^diff --git (.+)$/m.exec(chunk)?.[1];
+  return fileFromGitHeader(header ?? "");
+};
+var splitGitPatch = (patch) => {
+  const starts = [...patch.text.matchAll(/(?:^|\n)diff --git /g)].map((match) => match[0].startsWith(`
+`) ? match.index + 1 : match.index);
+  const chunks = starts.map((start, index) => patch.text.slice(start, starts[index + 1] ?? patch.text.length));
+  if (!patch.truncated)
+    return chunks;
+  return chunks.slice(0, -1);
+};
+var chunksByFile = (patch, fallback) => splitGitPatch(patch).reduce((acc, chunk, index) => {
+  const file = fileFromPatchChunk(chunk) ?? fallback(index);
+  if (!file)
+    return acc;
+  acc.set(file, (acc.get(file) ?? "") + chunk);
+  return acc;
+}, new Map);
+
+export { PATCH_CONTEXT_LINES, MAX_PATCH_BYTES, MAX_TOTAL_PATCH_BYTES, emptyPatch, addPatch, deletePatch, countPatch, fileFromPatchChunk, splitGitPatch, chunksByFile, exports_patch };