@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-sk3qaz4a.js

@@ -0,0 +1,511 @@
+// src/persistent-pty/daemon.ts
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import net from "node:net";
+import path from "node:path";
+import { Data, Duration, Effect, Schema, Semaphore } from "effect";
+var ProtocolVersion = 7;
+var MaxFrameBytes = 8 * 1024 * 1024;
+var Lifecycle = Schema.Union([
+  Schema.Struct({ status: Schema.Literal("running") }),
+  Schema.Struct({ status: Schema.Literal("exited"), exit_code: Schema.NullOr(Schema.Number) }),
+  Schema.Struct({ status: Schema.Literal("failed"), message: Schema.String })
+]);
+var WireTerminal2 = Schema.Struct({
+  id: Schema.Number,
+  pid: Schema.NullOr(Schema.Number),
+  title: Schema.String,
+  foreground_process: Schema.NullOr(Schema.String),
+  group_id: Schema.String,
+  command: Schema.Array(Schema.String),
+  cwd: Schema.String,
+  cols: Schema.Number,
+  rows: Schema.Number,
+  lifecycle: Lifecycle,
+  output_head: Schema.Number,
+  output_tail: Schema.Number
+});
+var Registration = Schema.Struct({
+  instance_id: Schema.String,
+  pid: Schema.Number,
+  protocol: Schema.Number,
+  socket: Schema.String,
+  token: Schema.String
+});
+var WireResponse2 = Schema.Union([
+  Schema.Struct({
+    type: Schema.Literal("pong"),
+    instance_id: Schema.String,
+    pid: Schema.Number,
+    protocol: Schema.Number
+  }),
+  Schema.Struct({ type: Schema.Literal("created"), terminal: WireTerminal2 }),
+  Schema.Struct({ type: Schema.Literal("terminals"), terminals: Schema.Array(WireTerminal2) }),
+  Schema.Struct({ type: Schema.Literal("ok") }),
+  Schema.Struct({ type: Schema.Literal("owned") }),
+  Schema.Struct({ type: Schema.Literal("handoff"), ticket: Schema.String, expires_at: Schema.Number }),
+  Schema.Struct({
+    type: Schema.Literal("snapshot"),
+    terminal: WireTerminal2,
+    text: Schema.String,
+    checkpoint_base64: Schema.String,
+    cursor_x: Schema.Number,
+    cursor_y: Schema.Number
+  }),
+  Schema.Struct({
+    type: Schema.Literal("rows"),
+    terminal: WireTerminal2,
+    lines: Schema.Array(Schema.String),
+    cursor_x: Schema.Number,
+    cursor_y: Schema.Number
+  }),
+  Schema.Struct({
+    type: Schema.Literal("attached"),
+    terminal: WireTerminal2,
+    role: Schema.Literals(["controller", "observer"]),
+    generation: Schema.Number,
+    requested_offset: Schema.Number,
+    available_offset: Schema.Number,
+    end_offset: Schema.Number,
+    truncated: Schema.Boolean,
+    replay_base64: Schema.String
+  }),
+  Schema.Struct({
+    type: Schema.Literal("resized"),
+    cols: Schema.Number,
+    rows: Schema.Number,
+    generation: Schema.Number,
+    checkpoint_base64: Schema.String
+  }),
+  Schema.Struct({
+    type: Schema.Literal("exited"),
+    exit_code: Schema.NullOr(Schema.Number),
+    final_offset: Schema.Number
+  }),
+  Schema.Struct({
+    type: Schema.Literal("controller_changed"),
+    attachment_id: Schema.NullOr(Schema.String),
+    generation: Schema.Number
+  }),
+  Schema.Struct({ type: Schema.Literal("title_changed"), title: Schema.String }),
+  Schema.Struct({ type: Schema.Literal("foreground_process_changed"), process: Schema.NullOr(Schema.String) }),
+  Schema.Struct({ type: Schema.Literal("error"), message: Schema.String })
+]);
+
+class DaemonError2 extends Data.TaggedError("PersistentPty.DaemonError") {
+}
+var makeDaemonTransport2 = Effect.fn("PersistentPty.makeDaemonTransport")(function* (directory, binary = () => Promise.resolve(process.env.OPENCODE_PTY_BIN || "opencode-pty"), inherited) {
+  const startup = Semaphore.makeUnsafe(1);
+  let registration;
+  let owner;
+  let closed = false;
+  yield* Effect.addFinalizer(() => Effect.sync(() => {
+    closed = true;
+    owner?.socket.destroy();
+  }));
+  const claim = (current, ticket) => Effect.tryPromise({
+    try: async (signal) => {
+      const connection = await openOwner(current, ticket, signal);
+      if (closed || signal.aborted) {
+        connection.socket.destroy();
+        throw new Error("PTY owner scope is closed");
+      }
+      owner = connection;
+      registration = current;
+      connection.socket.once("close", () => {
+        if (owner !== connection)
+          return;
+        owner = undefined;
+        registration = undefined;
+      });
+    },
+    catch: (cause) => failure("connect", cause)
+  }).pipe(Effect.timeoutOrElse({
+    duration: Duration.seconds(5),
+    orElse: () => Effect.fail(new DaemonError2({ kind: "connect", message: "PTY ownership claim timed out" }))
+  }));
+  const discover = Effect.fn("PersistentPty.daemon.discover")(function* () {
+    const value = yield* Effect.tryPromise({
+      try: () => readFile(path.join(directory, "service.json"), "utf8"),
+      catch: (cause) => failure("connect", cause)
+    });
+    const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Registration))(value).pipe(Effect.mapError((cause) => failure("protocol", cause)));
+    if (decoded.protocol !== ProtocolVersion)
+      return yield* Effect.fail(new DaemonError2({
+        kind: "protocol",
+        message: `opencode-pty protocol mismatch: daemon=${decoded.protocol}, client=${ProtocolVersion}`,
+        pid: decoded.pid
+      }));
+    const response = yield* oneShot(decoded, { op: "ping" });
+    if (response.type !== "pong" || response.instance_id !== decoded.instance_id || response.pid !== decoded.pid || response.protocol !== ProtocolVersion)
+      return yield* Effect.fail(new DaemonError2({ kind: "protocol", message: "opencode-pty registration mismatch" }));
+    return decoded;
+  });
+  const start = Effect.fn("PersistentPty.daemon.start")(function* () {
+    const executable = yield* Effect.tryPromise({ try: binary, catch: (cause) => failure("spawn", cause) });
+    const child = yield* Effect.tryPromise({
+      try: () => new Promise((resolve, reject) => {
+        const child = spawn(executable, ["daemon"], {
+          detached: true,
+          stdio: "ignore",
+          env: { ...process.env, OPENCODE_PTY_RUNTIME_DIR: directory }
+        });
+        child.once("spawn", () => {
+          child.unref();
+          resolve(child);
+        });
+        child.once("error", reject);
+      }),
+      catch: (cause) => failure("spawn", cause)
+    });
+    return yield* Effect.gen(function* () {
+      const deadline = Date.now() + 5000;
+      let last;
+      while (Date.now() < deadline) {
+        const found = yield* discover().pipe(Effect.map((value) => ({ value })), Effect.catch((error) => {
+          last = error;
+          return Effect.succeed(undefined);
+        }));
+        if (found) {
+          yield* claim(found.value);
+          return found.value;
+        }
+        yield* Effect.sleep(50);
+      }
+      return yield* Effect.fail(last ?? new DaemonError2({ kind: "connect", message: "opencode-pty did not become ready" }));
+    }).pipe(Effect.onError(() => Effect.sync(() => {
+      child.kill("SIGTERM");
+    })));
+  });
+  const connect = Effect.fn("PersistentPty.daemon.connect")(function* (shouldStart) {
+    if (closed)
+      return yield* Effect.fail(new DaemonError2({ kind: "connect", message: "PTY owner scope is closed" }));
+    if (registration)
+      return registration;
+    return yield* startup.withPermit(Effect.gen(function* () {
+      if (registration)
+        return registration;
+      const found = yield* discover().pipe(Effect.catch((error) => {
+        if (shouldStart && error.kind === "connect")
+          return start();
+        return Effect.fail(error);
+      }));
+      if (!owner)
+        yield* claim(found);
+      registration = found;
+      return found;
+    }));
+  });
+  const attempt = Effect.fn("PersistentPty.daemon.request-attempt")(function* (value, shouldStart) {
+    const current = yield* connect(shouldStart);
+    return yield* oneShot(current, value).pipe(Effect.catch((error) => {
+      if (error.kind === "registration" && registration === current)
+        registration = undefined;
+      return Effect.fail(error);
+    }));
+  });
+  const request = Effect.fn("PersistentPty.daemon.request")(function* (value, shouldStart = false) {
+    return yield* attempt(value, shouldStart).pipe(Effect.catch((error) => {
+      if (error.kind === "registration")
+        return attempt(value, shouldStart);
+      if (error.kind !== "connect")
+        return Effect.fail(error);
+      registration = undefined;
+      if (!shouldStart)
+        return Effect.fail(error);
+      return attempt(value, true);
+    }));
+  });
+  const requestIfRunning = (value) => request(value).pipe(Effect.catch((error) => error.kind === "connect" ? Effect.succeed(undefined) : Effect.fail(error)));
+  const shutdown = Effect.gen(function* () {
+    const response = yield* requestIfRunning({ op: "shutdown" });
+    registration = undefined;
+    if (!response)
+      return;
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+      const running = yield* discover().pipe(Effect.as(true), Effect.orElseSucceed(() => false));
+      if (!running)
+        return response;
+      yield* Effect.sleep(50);
+    }
+    return yield* Effect.fail(new DaemonError2({ kind: "connect", message: "opencode-pty did not stop" }));
+  });
+  const handoff = startup.withPermit(Effect.gen(function* () {
+    const current = owner;
+    const registered = registration;
+    if (!current || !registered)
+      return null;
+    const response = yield* Effect.tryPromise({
+      try: (signal) => current.exchange({ op: "prepare_handoff" }, signal),
+      catch: (cause) => failure("response", cause)
+    }).pipe(Effect.timeoutOrElse({
+      duration: Duration.seconds(5),
+      orElse: () => Effect.fail(new DaemonError2({ kind: "response", message: "PTY handoff preparation timed out" }))
+    }));
+    if (response.type !== "handoff")
+      return yield* Effect.fail(new DaemonError2({ kind: "protocol", message: "Expected PTY handoff ticket" }));
+    return { directory, instanceID: registered.instance_id, ticket: response.ticket, expiresAt: response.expires_at };
+  }));
+  const subscribe = Effect.fn("PersistentPty.daemon.subscribe")(function* (id, input) {
+    const attempt = Effect.gen(function* () {
+      const current = yield* connect(false);
+      return yield* Effect.tryPromise({
+        try: () => subscribePromise(current, id, input),
+        catch: (cause) => cause instanceof DaemonError2 ? cause : failure("connect", cause)
+      }).pipe(Effect.catch((error) => {
+        if (error.kind === "registration" && registration === current)
+          registration = undefined;
+        return Effect.fail(error);
+      }));
+    });
+    return yield* attempt.pipe(Effect.catch((error) => error.kind === "registration" ? attempt : Effect.fail(error)));
+  });
+  if (inherited) {
+    if (inherited.expiresAt <= Date.now())
+      return yield* Effect.fail(new DaemonError2({ kind: "registration", message: "PTY restart handoff expired" }));
+    const current = yield* discover();
+    if (current.instance_id !== inherited.instanceID)
+      return yield* Effect.fail(new DaemonError2({ kind: "registration", message: "PTY restart daemon changed" }));
+    yield* claim(current, inherited.ticket);
+  }
+  return { request, requestIfRunning, shutdown, handoff, subscribe };
+});
+async function openOwner(registration, ticket, signal) {
+  const socket = net.createConnection({ path: registration.socket });
+  const frames = decoder(socket);
+  const abort = () => socket.destroy();
+  signal.addEventListener("abort", abort, { once: true });
+  const exchange = async (request, signal) => {
+    if (signal.aborted)
+      throw new Error("PTY ownership request interrupted");
+    signal.addEventListener("abort", abort, { once: true });
+    try {
+      socket.write(encode({ token: registration.token, request }));
+      const frame = await frames.next();
+      if (frame.done)
+        throw new Error("PTY daemon closed its ownership connection");
+      const response = decode(frame.value);
+      if (response.type === "error")
+        throw new Error(response.message);
+      return response;
+    } finally {
+      signal.removeEventListener("abort", abort);
+    }
+  };
+  try {
+    await new Promise((resolve, reject) => {
+      socket.once("connect", resolve);
+      socket.once("error", reject);
+      socket.once("close", () => reject(new Error("PTY ownership connection closed")));
+    });
+    const response = await exchange({ op: "own", instance_id: registration.instance_id, ticket }, signal);
+    if (response.type !== "owned")
+      throw new Error("PTY daemon does not support server ownership");
+    socket.unref();
+    return { socket, exchange };
+  } catch (error) {
+    socket.destroy();
+    throw error;
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
+var oneShot = Effect.fn("PersistentPty.daemon.oneShot")(function* (registration, request) {
+  const payload = yield* Effect.try({
+    try: () => encode({ token: registration.token, request }),
+    catch: (cause) => failure("protocol", cause)
+  });
+  let dispatched = false;
+  return yield* Effect.acquireUseRelease(Effect.tryPromise({
+    try: (signal) => new Promise((resolve, reject) => {
+      const socket = net.createConnection({ path: registration.socket, signal });
+      socket.once("connect", () => resolve(socket));
+      socket.once("error", reject);
+    }),
+    catch: (cause) => failure("connect", cause)
+  }), (socket) => Effect.gen(function* () {
+    yield* Effect.try({
+      try: () => {
+        dispatched = true;
+        socket.write(payload);
+      },
+      catch: (cause) => failure("response", cause)
+    });
+    const first = yield* Effect.tryPromise({
+      try: async (signal) => {
+        const frames = decoder(socket);
+        const abort = () => socket.destroy();
+        signal.addEventListener("abort", abort, { once: true });
+        try {
+          const frame = await frames.next();
+          if (frame.done)
+            throw new Error("opencode-pty closed without response");
+          return frame.value;
+        } finally {
+          signal.removeEventListener("abort", abort);
+        }
+      },
+      catch: (cause) => failure("response", cause)
+    });
+    const response = yield* Effect.try({
+      try: () => decode(first),
+      catch: (cause) => failure("protocol", cause)
+    });
+    if (response.type === "error")
+      return yield* Effect.fail(new DaemonError2({
+        kind: response.message === "authentication failed" ? "registration" : "protocol",
+        message: response.message
+      }));
+    return response;
+  }), (socket) => Effect.sync(() => socket.destroy())).pipe(Effect.timeoutOrElse({
+    duration: Duration.seconds(5),
+    orElse: () => Effect.fail(new DaemonError2({
+      kind: dispatched ? "response" : "connect",
+      message: "opencode-pty request timed out"
+    }))
+  }));
+});
+async function subscribePromise(registration, id, input) {
+  const socket = net.createConnection(registration.socket);
+  const frames = decoder(socket);
+  try {
+    await new Promise((resolve, reject) => {
+      socket.once("connect", resolve);
+      socket.once("error", reject);
+    });
+    socket.write(encode({
+      token: registration.token,
+      request: {
+        op: "subscribe",
+        id,
+        offset: input.cursor,
+        attachment_id: input.attachmentID,
+        role: input.role,
+        takeover: input.takeover ?? false
+      }
+    }));
+    const initial = await frames.next();
+    if (initial.done)
+      throw new Error("opencode-pty closed before attachment");
+    const response = decode(initial.value);
+    if (response.type === "error")
+      throw new DaemonError2({
+        kind: response.message === "authentication failed" ? "registration" : "protocol",
+        message: response.message
+      });
+    if (response.type !== "attached")
+      throw new Error(`unexpected opencode-pty response: ${response.type}`);
+    let detached = false;
+    const pump = async () => {
+      try {
+        for await (const frame of frames) {
+          if (frame[0] === 0) {
+            if (frame.length < 17)
+              throw new Error("invalid opencode-pty output frame");
+            input.onEvent({
+              type: "output",
+              start: Number(frame.readBigUInt64BE(1)),
+              end: Number(frame.readBigUInt64BE(9)),
+              data: frame.subarray(17)
+            });
+            continue;
+          }
+          const event = decode(frame);
+          if (event.type === "resized")
+            input.onEvent({
+              type: "resized",
+              cols: event.cols,
+              rows: event.rows,
+              generation: event.generation,
+              checkpoint: Buffer.from(event.checkpoint_base64, "base64")
+            });
+          if (event.type === "controller_changed")
+            input.onEvent({
+              type: "controller_changed",
+              attachmentID: event.attachment_id ?? undefined,
+              generation: event.generation
+            });
+          if (event.type === "title_changed")
+            input.onEvent({ type: "title_changed", title: event.title });
+          if (event.type === "foreground_process_changed")
+            input.onEvent({ type: "foreground_process_changed", process: event.process });
+          if (event.type === "exited") {
+            input.onEvent({
+              type: "exited",
+              exitCode: event.exit_code ?? undefined,
+              finalOffset: event.final_offset
+            });
+            return;
+          }
+        }
+      } finally {
+        if (!detached)
+          input.onEnd();
+      }
+    };
+    let activated = false;
+    return {
+      terminal: response.terminal,
+      role: response.role,
+      generation: response.generation,
+      replay: {
+        requestedOffset: response.requested_offset,
+        availableOffset: response.available_offset,
+        endOffset: response.end_offset,
+        truncated: response.truncated,
+        data: Buffer.from(response.replay_base64, "base64")
+      },
+      activate() {
+        if (activated || detached)
+          return;
+        activated = true;
+        pump().catch(() => {});
+      },
+      detach() {
+        if (detached)
+          return;
+        detached = true;
+        socket.destroy();
+      }
+    };
+  } catch (error) {
+    socket.destroy();
+    throw error;
+  }
+}
+function encode(value) {
+  const payload = Buffer.from(JSON.stringify(value));
+  if (payload.length > MaxFrameBytes)
+    throw new Error("opencode-pty frame too large");
+  const output = Buffer.allocUnsafe(payload.length + 4);
+  output.writeUInt32BE(payload.length);
+  payload.copy(output, 4);
+  return output;
+}
+async function* decoder(socket) {
+  let pending = Buffer.alloc(0);
+  for await (const value of socket) {
+    const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+    pending = pending.length === 0 ? chunk : Buffer.concat([pending, chunk]);
+    while (pending.length >= 4) {
+      const length = pending.readUInt32BE(0);
+      if (length > MaxFrameBytes)
+        throw new Error("opencode-pty frame too large");
+      if (pending.length < length + 4)
+        break;
+      yield pending.subarray(4, length + 4);
+      pending = pending.subarray(length + 4);
+    }
+  }
+  if (pending.length !== 0)
+    throw new Error("opencode-pty truncated frame");
+}
+function decode(payload) {
+  return Schema.decodeUnknownSync(WireResponse2)(JSON.parse(Buffer.from(payload).toString("utf8")));
+}
+function failure(kind, cause) {
+  return new DaemonError2({ kind, message: cause instanceof Error ? cause.message : String(cause) });
+}
+
+export { WireTerminal2, WireResponse2, DaemonError2, makeDaemonTransport2 };

package/dist/chunks/aisdk-native-smbad60v.js

@@ -0,0 +1,130 @@
+import {
+  Service80,
+  node85
+} from "./aisdk-native-vfccn5yp.js";
+import {
+  SessionTable2,
+  SessionMessageTable2
+} from "./aisdk-native-a1bz86dw.js";
+import {
+  decodeMessageRow2,
+  load3
+} from "./aisdk-native-pvvztgda.js";
+import {
+  fromRow2
+} from "./aisdk-native-b09hzw3k.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/session/store.ts
+var exports_store = {};
+__export(exports_store, {
+  ListInput: () => ListInput5,
+  Service: () => Service61,
+  SessionStore: () => exports_store,
+  node: () => node65
+});
+import { and, asc, desc, eq, gt, isNotNull, isNull, like, lt, notInArray, or, sql } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Project } from "@opencode/schema/project";
+import { Workspace } from "@opencode/schema/workspace";
+import { AbsolutePath, PositiveInt, RelativePath } from "@opencode/schema/schema";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { Session } from "@opencode/schema/session";
+var ListInputBase = {
+  workspaceID: Workspace.ID.pipe(Schema.optional),
+  search: Schema.String.pipe(Schema.optional),
+  limit: PositiveInt.pipe(Schema.optional),
+  order: Schema.Literals(["asc", "desc"]).pipe(Schema.optional),
+  parentID: Schema.NullOr(Session.ID).pipe(Schema.optional),
+  anchor: Session.ListAnchor.pipe(Schema.optional)
+};
+var ListDirectoryInput = Schema.Struct({
+  ...ListInputBase,
+  directory: AbsolutePath
+});
+var ListProjectInput = Schema.Struct({
+  ...ListInputBase,
+  project: Project.ID,
+  subpath: RelativePath.pipe(Schema.optional)
+});
+var ListAllInput = Schema.Struct(ListInputBase);
+var ListInput5 = Schema.Union([ListDirectoryInput, ListProjectInput, ListAllInput]);
+
+class Service61 extends Context.Service()("@opencode/SessionStore") {
+}
+var layer = Layer.effect(Service61, Effect.gen(function* () {
+  const { db } = yield* Service80;
+  return Service61.of({
+    get: Effect.fnUntraced(function* (sessionID) {
+      const row = yield* db.select().from(SessionTable2).where(eq(SessionTable2.id, sessionID)).get().pipe(Effect.orDie);
+      return row ? fromRow2(row) : undefined;
+    }),
+    list: Effect.fn("SessionStore.list")(function* (input = {}) {
+      const direction = input.anchor?.direction ?? "next";
+      const requestedOrder = input.order ?? "desc";
+      const order = direction === "previous" ? requestedOrder === "asc" ? "desc" : "asc" : requestedOrder;
+      const sortColumn = SessionTable2.time_updated;
+      const conditions = [];
+      if ("directory" in input)
+        conditions.push(eq(SessionTable2.directory, input.directory));
+      if (input.workspaceID)
+        conditions.push(eq(SessionTable2.workspace_id, input.workspaceID));
+      if ("project" in input)
+        conditions.push(eq(SessionTable2.project_id, input.project));
+      if ("project" in input && input.subpath !== undefined)
+        conditions.push(eq(SessionTable2.path, input.subpath));
+      if (input.search)
+        conditions.push(like(SessionTable2.title, `%${input.search}%`));
+      if (input.parentID !== undefined)
+        conditions.push(input.parentID === null ? isNull(SessionTable2.parent_id) : eq(SessionTable2.parent_id, input.parentID));
+      if (input.anchor) {
+        conditions.push(order === "asc" ? or(gt(sortColumn, input.anchor.time), and(eq(sortColumn, input.anchor.time), gt(SessionTable2.id, input.anchor.id))) : or(lt(sortColumn, input.anchor.time), and(eq(sortColumn, input.anchor.time), lt(SessionTable2.id, input.anchor.id))));
+      }
+      const query = db.select().from(SessionTable2).where(conditions.length > 0 ? and(...conditions) : undefined).orderBy(order === "asc" ? asc(sortColumn) : desc(sortColumn), order === "asc" ? asc(SessionTable2.id) : desc(SessionTable2.id));
+      const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(Effect.orDie);
+      return (direction === "previous" ? rows.toReversed() : rows).map((row) => fromRow2(row));
+    }),
+    messages: Effect.fn("SessionStore.messages")(function* (input) {
+      const direction = input.cursor?.direction ?? "next";
+      const requestedOrder = input.order ?? "desc";
+      const order = direction === "previous" ? requestedOrder === "asc" ? "desc" : "asc" : requestedOrder;
+      const anchor = input.cursor ? yield* db.select({ seq: SessionMessageTable2.seq }).from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, input.sessionID), eq(SessionMessageTable2.id, input.cursor.id))).get().pipe(Effect.orDie) : undefined;
+      if (input.cursor && !anchor)
+        return [];
+      const boundary = anchor ? order === "asc" ? gt(SessionMessageTable2.seq, anchor.seq) : lt(SessionMessageTable2.seq, anchor.seq) : undefined;
+      const query = db.select().from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, input.sessionID), boundary, input.type === undefined ? undefined : eq(SessionMessageTable2.type, input.type))).orderBy(order === "asc" ? asc(SessionMessageTable2.seq) : desc(SessionMessageTable2.seq));
+      const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(Effect.orDie);
+      return yield* Effect.forEach(direction === "previous" ? rows.toReversed() : rows, decodeMessageRow2);
+    }),
+    context: Effect.fn("SessionStore.context")((sessionID) => load3(db, sessionID, "latest")),
+    message: Effect.fn("SessionStore.message")(function* (messageID) {
+      const row = yield* db.select().from(SessionMessageTable2).where(eq(SessionMessageTable2.id, messageID)).get().pipe(Effect.orDie);
+      return row ? {
+        sessionID: Session.ID.make(row.session_id),
+        message: yield* decodeMessageRow2(row).pipe(Effect.orDie)
+      } : undefined;
+    }),
+    listSuspended: Effect.fn("SessionStore.listSuspended")(function* () {
+      return yield* db.select({ sessionID: SessionTable2.id }).from(SessionTable2).where(and(isNotNull(SessionTable2.time_suspended), isNull(SessionTable2.parent_id))).all().pipe(Effect.orDie, Effect.map((rows) => rows.map((row) => row.sessionID)));
+    }),
+    claim: Effect.fn("SessionStore.claim")(function* (sessionID) {
+      yield* db.update(SessionTable2).set({ time_suspended: Date.now(), time_updated: sql`${SessionTable2.time_updated}` }).where(and(eq(SessionTable2.id, sessionID), isNull(SessionTable2.time_suspended))).run().pipe(Effect.orDie);
+    }),
+    release: Effect.fn("SessionStore.release")(function* (sessionID) {
+      yield* db.update(SessionTable2).set({ time_suspended: null, resume_attempts: 0, time_updated: sql`${SessionTable2.time_updated}` }).where(eq(SessionTable2.id, sessionID)).run().pipe(Effect.orDie);
+    }),
+    releaseChildClaims: Effect.fn("SessionStore.releaseChildClaims")((recoverable) => db.update(SessionTable2).set({ time_suspended: null, resume_attempts: 0, time_updated: sql`${SessionTable2.time_updated}` }).where(and(isNotNull(SessionTable2.time_suspended), isNotNull(SessionTable2.parent_id), recoverable.length > 0 ? notInArray(SessionTable2.id, Array.from(recoverable)) : undefined)).run().pipe(Effect.orDie, Effect.asVoid)),
+    countResume: Effect.fn("SessionStore.countResume")(function* (sessionID) {
+      const row = yield* db.update(SessionTable2).set({
+        resume_attempts: sql`${SessionTable2.resume_attempts} + 1`,
+        time_updated: sql`${SessionTable2.time_updated}`
+      }).where(eq(SessionTable2.id, sessionID)).returning({ attempts: SessionTable2.resume_attempts }).get().pipe(Effect.orDie);
+      return row?.attempts;
+    })
+  });
+}));
+var node65 = makeGlobalNode({ service: Service61, layer, deps: [node85] });
+
+export { ListInput5, Service61, node65, exports_store };

package/dist/chunks/aisdk-native-ssg3fenm.js

@@ -0,0 +1,22 @@
+// src/database/migration/20260602182828_add_project_directories.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260602182828_add_project_directories",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`project_directory\` (
+          \`project_id\` text NOT NULL,
+          \`directory\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`project_directory_pk\` PRIMARY KEY(\`project_id\`, \`directory\`),
+          CONSTRAINT \`fk_project_directory_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+    });
+  }
+};
+var _20260602182828_add_project_directories_default = migration;
+
+export { _20260602182828_add_project_directories_default };