@opencode/core 0.0.0-reserved → 2.0.0

package/dist/database/v1-migration.bun.js

@@ -0,0 +1,796 @@
+import {
+  exports_v1_migration
+} from "../chunks/aisdk-native-3tvqynh2.js";
+import"../chunks/aisdk-native-f0mxakyp.js";
+import"../chunks/aisdk-native-emrn6kk6.js";
+import"../chunks/aisdk-native-w3wsvvr9.js";
+import"../chunks/aisdk-native-7bmhse3q.js";
+import"../chunks/aisdk-native-cf4snx6d.js";
+import"../chunks/aisdk-native-822emrt2.js";
+import"../chunks/aisdk-native-wd87259q.js";
+import"../chunks/aisdk-native-m9w0rfyh.js";
+import"../chunks/aisdk-native-ch22x6z2.js";
+import"../chunks/aisdk-native-wggajky5.js";
+import"../chunks/aisdk-native-mb3974r6.js";
+import"../chunks/aisdk-native-361ty1x8.js";
+import"../chunks/aisdk-native-2q85qjqp.js";
+import"../chunks/aisdk-native-0zkw76rk.js";
+import"../chunks/aisdk-native-jzg6c2d5.js";
+import"../chunks/aisdk-native-q3sfg36h.js";
+import"../chunks/aisdk-native-1cnp2v09.js";
+import"../chunks/aisdk-native-rcb2kzg1.js";
+import"../chunks/aisdk-native-msx8hqn2.js";
+import"../chunks/aisdk-native-bkyjaxrp.js";
+import"../chunks/aisdk-native-g86h250q.js";
+import"../chunks/aisdk-native-jr7sbwjy.js";
+import"../chunks/aisdk-native-7m9af43g.js";
+import"../chunks/aisdk-native-j2ntwpah.js";
+import"../chunks/aisdk-native-njntx4h6.js";
+import"../chunks/aisdk-native-qrg20bc0.js";
+import"../chunks/aisdk-native-z9919s4g.js";
+import"../chunks/aisdk-native-43n2bw4t.js";
+import"../chunks/aisdk-native-n3j8tn72.js";
+import"../chunks/aisdk-native-d9jj8t3e.js";
+import"../chunks/aisdk-native-fd410y7t.js";
+import"../chunks/aisdk-native-e5kj55wp.js";
+import"../chunks/aisdk-native-f6n9ztr4.js";
+import"../chunks/aisdk-native-q74kybfr.js";
+import"../chunks/aisdk-native-53557ph1.js";
+import"../chunks/aisdk-native-7akdwqpd.js";
+import"../chunks/aisdk-native-wer8tq1h.js";
+import"../chunks/aisdk-native-wtztk69x.js";
+import"../chunks/aisdk-native-ssg3fenm.js";
+import"../chunks/aisdk-native-2c3vjs8z.js";
+import"../chunks/aisdk-native-17cy0kzp.js";
+import"../chunks/aisdk-native-hk9envan.js";
+import"../chunks/aisdk-native-w803qqfp.js";
+import"../chunks/aisdk-native-jwfs4k6c.js";
+import"../chunks/aisdk-native-mp448xyj.js";
+import"../chunks/aisdk-native-aqzs7mqg.js";
+import"../chunks/aisdk-native-ygaqb7jw.js";
+import"../chunks/aisdk-native-8n3pysct.js";
+import"../chunks/aisdk-native-d9fn303g.js";
+import"../chunks/aisdk-native-cvy3z8tj.js";
+import"../chunks/aisdk-native-9a4afbnw.js";
+import"../chunks/aisdk-native-n05xt0ee.js";
+import"../chunks/aisdk-native-sdp7kfr6.js";
+import"../chunks/aisdk-native-a6k6eb26.js";
+import"../chunks/aisdk-native-4knz6hnm.js";
+import"../chunks/aisdk-native-df08tz66.js";
+import"../chunks/aisdk-native-bmr6ed5q.js";
+import"../chunks/aisdk-native-atq7p7m5.js";
+import"../chunks/aisdk-native-qb87gjwd.js";
+import"../chunks/aisdk-native-359p4xyc.js";
+import"../chunks/aisdk-native-y8f7s663.js";
+import"../chunks/aisdk-native-b00gradr.js";
+import"../chunks/aisdk-native-twg0f83k.js";
+import"../chunks/aisdk-native-bfexjxds.js";
+import {
+  Service80
+} from "../chunks/aisdk-native-vfccn5yp.js";
+import"../chunks/aisdk-native-922hggd3.js";
+import"../chunks/aisdk-native-6msgmcgs.js";
+import"../chunks/aisdk-native-qfa1cgps.js";
+import"../chunks/aisdk-native-8p4f9s12.js";
+import {
+  SessionTable2,
+  SessionMessageTable2
+} from "../chunks/aisdk-native-a1bz86dw.js";
+import {
+  SessionMessage2
+} from "../chunks/aisdk-native-gftt206x.js";
+import {
+  SessionSchema2
+} from "../chunks/aisdk-native-y6f0p4jw.js";
+import {
+  KVTable2
+} from "../chunks/aisdk-native-3hepkmqq.js";
+import {
+  EventSequenceTable2
+} from "../chunks/aisdk-native-2710q6r3.js";
+
+// src/database/v1-migration.bun.ts
+import { Cause, Effect, Layer, Option, Schema, Semaphore } from "effect";
+import { SessionV1 } from "@opencode/schema/session-v1";
+import { eq, sql } from "drizzle-orm";
+import { Global } from "@opencode/util/global";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { Project } from "@opencode/schema/project";
+var NEXT_PROJECT_COLUMNS = {
+  id: "required",
+  worktree: "required",
+  vcs: "nullable",
+  name: "nullable",
+  icon_url: "nullable",
+  icon_url_override: { fallback: "icon_url" },
+  icon_color: "nullable",
+  time_created: "required",
+  time_updated: "required",
+  time_initialized: "nullable",
+  sandboxes: "required",
+  commands: "nullable"
+};
+var NEXT_SESSION_COLUMNS = {
+  id: "required",
+  project_id: "required",
+  workspace_id: "nullable",
+  parent_id: "nullable",
+  fork_session_id: "nullable",
+  fork_boundary: "nullable",
+  slug: "required",
+  directory: "required",
+  path: "nullable",
+  title: "nullable",
+  version: "required",
+  share_url: "nullable",
+  summary_additions: "nullable",
+  summary_deletions: "nullable",
+  summary_files: "nullable",
+  summary_diffs: "nullable",
+  metadata: "nullable",
+  cost: "required",
+  tokens_input: "required",
+  tokens_output: "required",
+  tokens_reasoning: "required",
+  tokens_cache_read: "required",
+  tokens_cache_write: "required",
+  revert: "nullable",
+  permission: "nullable",
+  agent: "nullable",
+  model: "nullable",
+  time_created: "required",
+  time_updated: "required",
+  time_compacting: "nullable",
+  time_archived: "nullable",
+  time_suspended: "nullable"
+};
+var lock = Semaphore.makeUnsafe(1);
+var MIGRATION_STATE_KEY = "migration.v1-v2";
+var EVENT_DELETE_BATCH_SIZE = 1000;
+var decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
+var decodeMessage = Schema.decodeUnknownOption(SessionV1.Info);
+var decodePart = Schema.decodeUnknownOption(SessionV1.Part);
+var runtimeState = { status: "idle" };
+function transformSession(input) {
+  const warnings = [];
+  const messages = input.messages.map((row) => {
+    const value = Option.getOrUndefined(decodeJson(row.data));
+    const decoded = value && typeof value === "object" ? Option.getOrUndefined(decodeMessage({ ...value, id: row.id, sessionID: row.session_id })) : undefined;
+    if (decoded)
+      return { row, value: decoded };
+    warnings.push({ reason: "invalid-message", sessionID: input.session.id, messageID: row.id });
+    return;
+  }).filter((item) => item !== undefined).sort((a, b) => a.row.time_created - b.row.time_created || a.row.id.localeCompare(b.row.id));
+  const messageIDs = new Set(input.messages.map((row) => row.id));
+  const parts = input.parts.map((row) => {
+    const value = Option.getOrUndefined(decodeJson(row.data));
+    const observedType = value && typeof value === "object" && "type" in value ? String(value.type) : undefined;
+    if (!messageIDs.has(row.message_id)) {
+      warnings.push({
+        reason: "orphan-part",
+        sessionID: input.session.id,
+        messageID: row.message_id,
+        partID: row.id,
+        observedType
+      });
+      return;
+    }
+    const decoded = value && typeof value === "object" ? Option.getOrUndefined(decodePart({ ...value, id: row.id, messageID: row.message_id, sessionID: row.session_id })) : undefined;
+    if (decoded)
+      return { row, value: decoded };
+    warnings.push({
+      reason: "invalid-part",
+      sessionID: input.session.id,
+      messageID: row.message_id,
+      partID: row.id,
+      observedType
+    });
+    return;
+  }).filter((item) => item !== undefined).sort((a, b) => a.row.id.localeCompare(b.row.id));
+  const byMessage = Map.groupBy(parts, (item) => item.row.message_id);
+  const paired = new Set;
+  const used = new Set(messages.map((item) => item.row.id));
+  const projected = messages.flatMap((item) => {
+    if (paired.has(item.row.id))
+      return [];
+    const owned = byMessage.get(item.row.id)?.map((part) => part.value) ?? [];
+    if (item.value.role === "user") {
+      const compaction = owned.find((part) => part.type === "compaction");
+      if (compaction) {
+        const pairedSummary = messages.find((candidate) => candidate.value.role === "assistant" && candidate.value.parentID === item.row.id && candidate.value.summary === true);
+        if (!pairedSummary)
+          return [];
+        paired.add(pairedSummary.row.id);
+        if (pairedSummary.value.error || pairedSummary.value.time.completed === undefined)
+          return [];
+        const summary = pairedSummary;
+        const summaryText = (byMessage.get(summary.row.id) ?? []).map((part) => part.value).filter((part) => part.type === "text" && part.text.length > 0).map((part) => part.text).join(`
+
+`);
+        const tailIndex = compaction.tail_start_id ? messages.findIndex((candidate) => candidate.row.id === compaction.tail_start_id) : -1;
+        const compactionIndex = messages.findIndex((candidate) => candidate.row.id === item.row.id);
+        const tail = tailIndex < 0 ? [] : messages.slice(tailIndex, compactionIndex);
+        return [
+          row({ ...item.row, time_updated: Math.max(item.row.time_updated, summary.row.time_updated) }, {
+            id: item.row.id,
+            type: "compaction",
+            status: "completed",
+            reason: compaction.auto ? "auto" : "manual",
+            summary: summaryText,
+            recent: serializeRecent(tail, byMessage),
+            time: { created: item.row.time_created }
+          })
+        ];
+      }
+      const subtasks = owned.filter((part) => part.type === "subtask");
+      const visible = owned.filter((part) => part.type === "text" && !part.ignored);
+      const files = owned.filter((part) => part.type === "file");
+      const agents = owned.filter((part) => part.type === "agent");
+      if (subtasks.length > 0 && visible.length === 0 && files.length === 0 && agents.length === 0)
+        return [];
+      const ordinary = visible.filter((part) => !part.synthetic);
+      const synthetic = visible.filter((part) => part.synthetic);
+      const attachments = files.flatMap((part) => migrateFile(part));
+      const unavailable = files.flatMap((part) => !part.url.startsWith("data:") ? [unavailableFile(part)] : []);
+      const text = owned.flatMap((part) => {
+        if (part.type === "text" && !part.ignored && !part.synthetic)
+          return [part.text];
+        if (part.type === "file" && !part.url.startsWith("data:"))
+          return [unavailableFile(part)];
+        return [];
+      }).join(`
+
+`);
+      const agentAttachments = agents.map((part) => ({
+        name: part.name,
+        ...part.source ? { mention: { text: part.source.value, start: part.source.start, end: part.source.end } } : {}
+      }));
+      if (ordinary.length === 0 && unavailable.length === 0 && synthetic.length > 0 && attachments.length === 0 && agentAttachments.length === 0)
+        return [
+          row(item.row, {
+            id: item.row.id,
+            type: "synthetic",
+            text: synthetic.map((part) => part.text).join(`
+
+`),
+            time: { created: item.row.time_created }
+          })
+        ];
+      const user = row(item.row, {
+        id: item.row.id,
+        type: "user",
+        text,
+        ...attachments.length ? { files: attachments } : {},
+        ...agentAttachments.length ? { agents: agentAttachments } : {},
+        time: { created: item.row.time_created }
+      });
+      if (synthetic.length === 0)
+        return [user];
+      return [
+        user,
+        row(item.row, {
+          id: syntheticID(item.row.id, used),
+          type: "synthetic",
+          text: synthetic.map((part) => part.text).join(`
+
+`),
+          time: { created: item.row.time_created }
+        })
+      ];
+    }
+    if (item.value.role !== "assistant")
+      return [];
+    const assistant = item.value;
+    const parent = messages.find((candidate) => candidate.row.id === assistant.parentID);
+    const parentParts = parent ? byMessage.get(parent.row.id)?.map((part) => part.value) ?? [] : [];
+    if (parentParts.some((part) => part.type === "subtask") && owned.some((part) => part.type === "tool" && part.tool === "task"))
+      return [];
+    const content = owned.flatMap((part) => {
+      if (part.type === "text")
+        return [{ type: "text", text: part.text, ...part.metadata ? { state: part.metadata } : {} }];
+      if (part.type === "reasoning")
+        return [
+          {
+            type: "reasoning",
+            text: part.text,
+            ...part.metadata ? { state: part.metadata } : {},
+            time: { created: part.time.start, ...part.time.end === undefined ? {} : { completed: part.time.end } }
+          }
+        ];
+      if (part.type !== "tool")
+        return [];
+      return [migrateTool(part, item.row.time_created)];
+    });
+    const start = owned.flatMap((part) => part.type === "step-start" && part.snapshot ? [part.snapshot] : [])[0] ?? owned.flatMap((part) => part.type === "snapshot" ? [part.snapshot] : [])[0] ?? owned.flatMap((part) => part.type === "patch" ? [part.hash] : [])[0];
+    const end = owned.flatMap((part) => part.type === "step-finish" && part.snapshot ? [part.snapshot] : []).at(-1);
+    const snapshotFiles = Array.from(new Set(owned.flatMap((part) => part.type === "patch" ? part.files : [])));
+    const finish = normalizeFinish(assistant.finish);
+    return [
+      row(item.row, {
+        id: item.row.id,
+        type: "assistant",
+        agent: assistant.agent,
+        model: {
+          providerID: assistant.providerID,
+          id: assistant.modelID,
+          variant: assistant.variant ?? "default"
+        },
+        content,
+        ...start || end || snapshotFiles.length ? {
+          snapshot: {
+            ...start ? { start } : {},
+            ...end ? { end } : {},
+            ...snapshotFiles.length ? { files: snapshotFiles } : {}
+          }
+        } : {},
+        ...finish ? { finish } : {},
+        cost: assistant.cost,
+        tokens: {
+          input: assistant.tokens.input,
+          output: assistant.tokens.output,
+          reasoning: assistant.tokens.reasoning,
+          cache: assistant.tokens.cache
+        },
+        ...assistant.error ? { error: migrateError(assistant.error) } : {},
+        time: {
+          created: item.row.time_created,
+          ...assistant.time.completed === undefined ? {} : { completed: item.row.time_updated }
+        }
+      })
+    ];
+  }).map((item, seq) => ({ ...item, seq }));
+  const assistants = messages.map((item) => item.value).filter((item) => item.role === "assistant");
+  const latestUser = messages.findLast((item) => {
+    if (item.value.role !== "user")
+      return false;
+    const owned = byMessage.get(item.row.id) ?? [];
+    if (owned.some((part) => part.value.type === "compaction"))
+      return false;
+    return !owned.some((part) => part.value.type === "subtask") || !owned.every((part) => part.value.type === "subtask");
+  });
+  return {
+    messages: projected,
+    session: {
+      agent: input.session.agent ?? (latestUser?.value.role === "user" ? latestUser.value.agent : null),
+      model: input.session.model ?? (latestUser?.value.role === "user" ? {
+        id: latestUser.value.model.modelID,
+        providerID: latestUser.value.model.providerID,
+        variant: latestUser.value.model.variant ?? "default"
+      } : null),
+      cost: assistants.reduce((total, item) => total + item.cost, 0),
+      tokens_input: assistants.reduce((total, item) => total + item.tokens.input, 0),
+      tokens_output: assistants.reduce((total, item) => total + item.tokens.output, 0),
+      tokens_reasoning: assistants.reduce((total, item) => total + item.tokens.reasoning, 0),
+      tokens_cache_read: assistants.reduce((total, item) => total + item.tokens.cache.read, 0),
+      tokens_cache_write: assistants.reduce((total, item) => total + item.tokens.cache.write, 0),
+      revert: null,
+      time_compacting: null
+    },
+    watermark: projected.length - 1,
+    warnings
+  };
+}
+function status() {
+  return Effect.gen(function* () {
+    const db = (yield* Service80).db;
+    if (!(yield* hasLegacySessions(db)))
+      return { status: "completed" };
+    const state = yield* readState(db);
+    if (runtimeState.status === "running")
+      return runtimeState;
+    if (runtimeState.status === "error")
+      return runtimeState;
+    if (state?.phase === "completed")
+      return { status: "completed" };
+    return { status: "required" };
+  });
+}
+var layer = Layer.effectDiscard(Effect.gen(function* () {
+  runtimeState = { status: "running", progress: { label: "Clearing old events" } };
+  yield* run().pipe(Effect.matchCauseEffect({
+    onFailure: (cause) => Effect.sync(() => {
+      runtimeState = { status: "error", error: errorText(Cause.squash(cause)) };
+    }).pipe(Effect.andThen(Effect.logError("V1 migration failed", { cause }))),
+    onSuccess: () => Effect.sync(() => {
+      runtimeState = { status: "idle" };
+    })
+  }), Effect.forkScoped({ startImmediately: true }));
+}));
+function errorText(input) {
+  if (!(input instanceof Error))
+    return String(input);
+  const cause = input.cause;
+  return cause === undefined ? input.message : `${input.message}
+Caused by: ${errorText(cause)}`;
+}
+function updateProgress(progress) {
+  if (runtimeState.status === "running")
+    runtimeState = { status: "running", progress };
+}
+function run(options = {}) {
+  return lock.withPermit(Effect.gen(function* () {
+    const db = (yield* Service80).db;
+    const global = yield* Global.Service;
+    const state = yield* readState(db);
+    if (state?.phase === "completed")
+      return { status: "completed" };
+    if (!(yield* hasLegacySessions(db)))
+      return { status: "completed" };
+    const now = Date.now();
+    yield* db.run(sql`
+          INSERT OR IGNORE INTO project (id, worktree, time_created, time_updated, sandboxes)
+          VALUES (${Project.ID.global}, ${path.parse(global.data).root}, ${now}, ${now}, '[]')
+        `);
+    if (state === undefined)
+      yield* db.transaction((tx) => Effect.gen(function* () {
+        while (true) {
+          yield* tx.run(sql`
+                    DELETE FROM event
+                    WHERE rowid IN (SELECT rowid FROM event LIMIT ${EVENT_DELETE_BATCH_SIZE})
+                  `);
+          const deleted = (yield* tx.get(sql`SELECT changes() AS value`))?.value ?? 0;
+          if (deleted < EVENT_DELETE_BATCH_SIZE)
+            break;
+          yield* Effect.yieldNow;
+        }
+        yield* tx.insert(KVTable2).values({ key: MIGRATION_STATE_KEY, value: { phase: "sessions" } }).run();
+      })).pipe(Effect.orDie);
+    const sourceTotal = yield* countNextSessions(nextPath(options, global.data));
+    const legacyTotal = (yield* db.get(sql`SELECT COUNT(*) AS value FROM session`))?.value ?? 0;
+    const cursor = state?.phase === "sessions" ? state.cursor : undefined;
+    const migrated = cursor !== undefined ? (yield* db.get(sql`SELECT COUNT(*) AS value FROM session WHERE id >= ${cursor}`))?.value ?? 0 : 0;
+    const denominator = sourceTotal + legacyTotal;
+    updateProgress({ label: "Migrating sessions", numerator: migrated, denominator });
+    yield* importNextDatabase(db, nextPath(options, global.data), (completed) => {
+      updateProgress({ label: "Migrating sessions", numerator: migrated + completed, denominator });
+    });
+    updateProgress({ label: "Migrating sessions", numerator: migrated + sourceTotal, denominator });
+    const projects = new Set((yield* db.all(sql`SELECT id FROM project`)).map((project) => project.id));
+    while (true) {
+      const state = yield* readState(db);
+      const cursorValue = state?.phase === "sessions" ? state.cursor : undefined;
+      const nextID = yield* db.get(cursorValue === undefined ? sql`SELECT id, project_id FROM session ORDER BY id DESC LIMIT 1` : sql`SELECT id, project_id FROM session WHERE id < ${cursorValue} ORDER BY id DESC LIMIT 1`);
+      if (!nextID)
+        break;
+      yield* db.transaction((tx) => Effect.gen(function* () {
+        yield* tx.insert(KVTable2).values({ key: MIGRATION_STATE_KEY, value: { phase: "sessions", cursor: nextID.id } }).onConflictDoUpdate({
+          target: KVTable2.key,
+          set: { value: { phase: "sessions", cursor: nextID.id }, time_updated: Date.now() }
+        }).run();
+        const projectID = projects.has(nextID.project_id) ? nextID.project_id : Project.ID.global;
+        if (projectID !== nextID.project_id)
+          yield* Effect.logWarning("Reassigned V1 session with missing project", {
+            sessionID: nextID.id,
+            projectID: nextID.project_id
+          });
+        yield* tx.run(sql`
+                  INSERT OR IGNORE INTO session_v2 (
+                    id, project_id, workspace_id, parent_id, slug, directory, path, title, version, share_url,
+                    summary_additions, summary_deletions, summary_files, summary_diffs, metadata, cost,
+                    tokens_input, tokens_output, tokens_reasoning, tokens_cache_read, tokens_cache_write,
+                    revert, permission, agent, model, time_created, time_updated, time_compacting, time_archived
+                  )
+                  SELECT
+                    id, ${projectID}, workspace_id, parent_id, slug, directory, path, title, version, share_url,
+                    summary_additions, summary_deletions, summary_files, summary_diffs, metadata, cost,
+                    tokens_input, tokens_output, tokens_reasoning, tokens_cache_read, tokens_cache_write,
+                    revert, NULL, agent, model, time_created, time_updated, time_compacting, time_archived
+                  FROM session
+                  WHERE id = ${nextID.id}
+                `);
+        const next = yield* tx.select().from(SessionTable2).where(eq(SessionTable2.id, SessionSchema2.ID.make(nextID.id))).get();
+        if (!next)
+          return yield* Effect.die(new Error(`Failed to copy V1 session ${nextID.id}`));
+        const sourceMessages = yield* tx.all(sql`SELECT id, session_id, time_created, time_updated, data FROM message WHERE session_id = ${next.id}`);
+        const sourceParts = yield* tx.all(sql`SELECT id, message_id, session_id, time_created, time_updated, data FROM part WHERE session_id = ${next.id}`);
+        const transformed = transformSession({ session: next, messages: sourceMessages, parts: sourceParts });
+        yield* Effect.forEach(transformed.warnings, (warning) => Effect.logWarning("Skipped V1 migration row", warning));
+        yield* tx.delete(SessionMessageTable2).where(eq(SessionMessageTable2.session_id, next.id)).run();
+        yield* Effect.forEach(transformed.messages, (message) => tx.insert(SessionMessageTable2).values({
+          id: SessionMessage2.ID.make(message.id),
+          session_id: SessionSchema2.ID.make(message.session_id),
+          type: message.type,
+          seq: message.seq,
+          time_created: message.time_created,
+          time_updated: message.time_updated,
+          data: sql`${JSON.stringify(message.data)}`
+        }).run());
+        yield* tx.update(SessionTable2).set({ ...transformed.session, time_updated: next.time_updated }).where(eq(SessionTable2.id, next.id)).run();
+        yield* tx.insert(EventSequenceTable2).values({ aggregate_id: next.id, seq: transformed.watermark }).onConflictDoUpdate({
+          target: EventSequenceTable2.aggregate_id,
+          set: { seq: transformed.watermark, owner_id: null }
+        }).run();
+      })).pipe(Effect.orDie);
+      if (runtimeState.status === "running")
+        runtimeState = {
+          status: "running",
+          progress: {
+            label: "Migrating sessions",
+            numerator: (runtimeState.progress.numerator ?? 0) + 1,
+            denominator
+          }
+        };
+      yield* Effect.yieldNow;
+    }
+    yield* db.transaction((tx) => Effect.gen(function* () {
+      yield* tx.insert(KVTable2).values({ key: MIGRATION_STATE_KEY, value: { phase: "completed" } }).onConflictDoUpdate({
+        target: KVTable2.key,
+        set: { value: { phase: "completed" }, time_updated: Date.now() }
+      }).run();
+    })).pipe(Effect.orDie);
+    return { status: "completed" };
+  }).pipe(Effect.orDie));
+}
+function nextPath(options, data) {
+  if (options.nextDatabasePath)
+    return options.nextDatabasePath;
+  if (process.env.OPENCODE_DB === ":memory:")
+    return;
+  return path.join(data, "opencode-next.db");
+}
+function openNextDatabase(sourcePath) {
+  return Effect.acquireRelease(Effect.gen(function* () {
+    const sqlite = yield* Effect.promise(() => import("bun:sqlite"));
+    return new sqlite.Database(sourcePath, { readonly: true, strict: true });
+  }), (source) => Effect.sync(() => source.close()));
+}
+function countNextSessions(sourcePath) {
+  if (!sourcePath || !existsSync(sourcePath))
+    return Effect.succeed(0);
+  return Effect.scoped(Effect.gen(function* () {
+    const source = yield* openNextDatabase(sourcePath);
+    if (!isNextDatabase(source))
+      return 0;
+    return source.query("SELECT COUNT(*) AS value FROM session").get()?.value ?? 0;
+  }));
+}
+function importNextDatabase(db, sourcePath, onProgress) {
+  if (!sourcePath || !existsSync(sourcePath))
+    return Effect.void;
+  return Effect.scoped(Effect.gen(function* () {
+    const source = yield* openNextDatabase(sourcePath);
+    if (!isNextDatabase(source)) {
+      yield* Effect.logWarning("Skipped incompatible opencode-next.db", { path: sourcePath });
+      return;
+    }
+    source.run("BEGIN");
+    yield* Effect.addFinalizer(() => Effect.sync(() => {
+      if (source.inTransaction)
+        source.run("ROLLBACK");
+    }));
+    const projects = new Map(selectNextRows(source, "project", NEXT_PROJECT_COLUMNS).map((project) => [project.id, project]));
+    const sessions = selectNextRows(source, "session", NEXT_SESSION_COLUMNS);
+    for (const [index, session] of sessions.entries()) {
+      const project = projects.get(session.project_id);
+      const projectID = project ? session.project_id : Project.ID.global;
+      if (!project) {
+        yield* Effect.logWarning("Reassigned previous V2 session with missing project", {
+          sessionID: session.id,
+          projectID: session.project_id
+        });
+      }
+      const messages = source.query("SELECT id, session_id, type, seq, time_created, time_updated, data FROM session_message WHERE session_id = ? ORDER BY seq").all(session.id);
+      yield* db.transaction((tx) => Effect.gen(function* () {
+        if (project)
+          yield* tx.run(sql`
+                  INSERT OR IGNORE INTO project (
+                    id, worktree, vcs, name, icon_url, icon_url_override, icon_color,
+                    time_created, time_updated, time_initialized, sandboxes, commands
+                  ) VALUES (
+                    ${project.id}, ${project.worktree}, ${project.vcs}, ${project.name}, ${project.icon_url},
+                    ${project.icon_url_override}, ${project.icon_color}, ${project.time_created}, ${project.time_updated},
+                    ${project.time_initialized}, ${project.sandboxes}, ${project.commands}
+                  )
+                `);
+        const existing = yield* tx.select({ id: SessionTable2.id }).from(SessionTable2).where(eq(SessionTable2.id, SessionSchema2.ID.make(session.id))).get();
+        if (existing)
+          return;
+        yield* tx.run(sql`
+                INSERT INTO session_v2 (
+                  id, project_id, workspace_id, parent_id, fork_session_id, fork_boundary, slug, directory,
+                  path, title, version, share_url, summary_additions, summary_deletions, summary_files,
+                  summary_diffs, metadata, cost, tokens_input, tokens_output, tokens_reasoning, tokens_cache_read,
+                  tokens_cache_write, revert, permission, agent, model, time_created, time_updated, time_compacting,
+                  time_archived, time_suspended
+                ) VALUES (
+                  ${session.id}, ${projectID}, ${session.workspace_id}, ${session.parent_id},
+                  ${session.fork_session_id}, ${session.fork_boundary}, ${session.slug}, ${session.directory},
+                  ${session.path}, ${session.title}, ${session.version}, ${session.share_url},
+                  ${session.summary_additions}, ${session.summary_deletions}, ${session.summary_files},
+                  ${session.summary_diffs}, ${session.metadata}, ${session.cost}, ${session.tokens_input},
+                  ${session.tokens_output}, ${session.tokens_reasoning}, ${session.tokens_cache_read},
+                  ${session.tokens_cache_write}, ${session.revert}, ${session.permission}, ${session.agent},
+                  ${session.model}, ${session.time_created}, ${session.time_updated}, ${session.time_compacting},
+                  ${session.time_archived}, ${session.time_suspended}
+                )
+              `);
+        yield* Effect.forEach(messages, (message) => tx.insert(SessionMessageTable2).values({
+          id: SessionMessage2.ID.make(message.id),
+          session_id: SessionSchema2.ID.make(message.session_id),
+          type: message.type,
+          seq: message.seq,
+          time_created: message.time_created,
+          time_updated: message.time_updated,
+          data: sql`${message.data}`
+        }).run());
+        yield* tx.insert(EventSequenceTable2).values({ aggregate_id: session.id, seq: messages.at(-1)?.seq ?? -1 }).onConflictDoUpdate({
+          target: EventSequenceTable2.aggregate_id,
+          set: { seq: messages.at(-1)?.seq ?? -1, owner_id: null }
+        }).run();
+      })).pipe(Effect.orDie);
+      onProgress(index + 1);
+      yield* Effect.yieldNow;
+    }
+    source.run("COMMIT");
+  }));
+}
+function isNextDatabase(source) {
+  const tables = new Set(source.query("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((table) => table.name));
+  return tables.has("project") && tables.has("session") && tables.has("session_message");
+}
+function selectNextRows(source, table, definition) {
+  const columns = new Set(source.query("SELECT name FROM pragma_table_info(?)").all(table).map((column) => column.name));
+  const missing = Object.entries(definition).filter(([column, strategy]) => strategy === "required" && !columns.has(column)).map(([column]) => column);
+  if (missing.length)
+    throw new Error(`Incompatible opencode-next.db: ${table} is missing required columns: ${missing.join(", ")}`);
+  const projection = Object.entries(definition).map(([column, strategy]) => {
+    if (columns.has(column))
+      return `"${column}"`;
+    if (typeof strategy === "object" && strategy !== null && "fallback" in strategy && typeof strategy.fallback === "string" && columns.has(strategy.fallback))
+      return `"${strategy.fallback}" AS "${column}"`;
+    return `NULL AS "${column}"`;
+  });
+  return source.query(`SELECT ${projection.join(", ")} FROM "${table}"${table === "session" ? ' ORDER BY "id" DESC' : ""}`).all();
+}
+function row(source, message) {
+  const { id, type, ...data } = message;
+  return {
+    id,
+    session_id: source.session_id,
+    type,
+    seq: 0,
+    time_created: source.time_created,
+    time_updated: source.time_updated,
+    data
+  };
+}
+function migrateTool(part, fallback) {
+  const base = {
+    type: "tool",
+    id: part.callID,
+    name: part.tool,
+    ...part.metadata ? { providerState: part.metadata } : {}
+  };
+  if (part.state.status === "completed")
+    return {
+      ...base,
+      state: {
+        status: "completed",
+        input: part.state.input,
+        content: part.state.time.compacted === undefined ? [
+          { type: "text", text: part.state.output },
+          ...(part.state.attachments ?? []).map((file) => ({
+            type: "file",
+            uri: file.url,
+            mime: file.mime,
+            ...file.filename ? { name: file.filename } : {}
+          }))
+        ] : [{ type: "text", text: "[Old tool result content cleared]" }],
+        metadata: part.state.metadata
+      },
+      time: { created: part.state.time.start, completed: part.state.time.end }
+    };
+  if (part.state.status === "error")
+    return {
+      ...base,
+      state: {
+        status: "error",
+        input: part.state.input,
+        error: { type: "tool.execution", message: part.state.error },
+        ...typeof part.state.metadata?.output === "string" ? { content: [{ type: "text", text: part.state.metadata.output }] } : {},
+        ...part.state.metadata ? { metadata: part.state.metadata } : {}
+      },
+      time: { created: part.state.time.start, completed: part.state.time.end }
+    };
+  return {
+    ...base,
+    state: {
+      status: "error",
+      input: part.state.input,
+      error: { type: "tool.interrupted", message: "Tool execution was interrupted before V2 migration" },
+      ...part.state.status === "running" && part.state.metadata ? { metadata: part.state.metadata } : {}
+    },
+    time: { created: part.state.status === "running" ? part.state.time.start : fallback }
+  };
+}
+function migrateError(error) {
+  const message = "message" in error.data ? error.data.message : error.name === "MessageOutputLengthError" ? "The model exceeded its output limit" : error.name;
+  const type = error.name === "ProviderAuthError" ? "provider.auth" : error.name === "ContentFilterError" ? "provider.content-filter" : error.name === "ContextOverflowError" ? "provider.invalid-request" : error.name === "StructuredOutputError" || error.name === "MessageOutputLengthError" ? "provider.invalid-output" : error.name === "MessageAbortedError" ? "aborted" : error.name === "APIError" ? "provider.error" : "unknown";
+  return { type, message };
+}
+function normalizeFinish(finish) {
+  if (!finish)
+    return;
+  return ["stop", "length", "tool-calls", "content-filter", "error", "unknown"].find((value) => value === finish) ?? "unknown";
+}
+function migrateFile(part) {
+  if (!part.url.startsWith("data:"))
+    return [];
+  const comma = part.url.indexOf(",");
+  if (comma < 0)
+    return [];
+  const header = part.url.slice(0, comma);
+  const payload = part.url.slice(comma + 1);
+  const data = header.endsWith(";base64") ? Buffer.from(payload, "base64").toString("base64") : Buffer.from(decodeURIComponent(payload)).toString("base64");
+  return [
+    {
+      data,
+      mime: part.mime,
+      source: part.source?.type === "resource" ? { type: "uri", uri: part.source.uri } : { type: "inline" },
+      ...part.filename ? { name: part.filename } : {},
+      ...part.source ? { mention: { text: part.source.text.value, start: part.source.text.start, end: part.source.text.end } } : {}
+    }
+  ];
+}
+function unavailableFile(part) {
+  const label = part.filename ?? (part.source?.type === "resource" ? part.source.uri : part.url);
+  return `[Attachment unavailable after migration: ${label} (${part.mime})]`;
+}
+function syntheticID(source, used) {
+  const prefix = source.slice(0, 16);
+  const alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  for (let salt = 0;; salt++) {
+    const hex = new Bun.CryptoHasher("sha256").update(`v1-synthetic:${source}${salt ? `:${salt}` : ""}`).digest("hex");
+    let value = BigInt(`0x${hex}`);
+    let suffix = "";
+    while (suffix.length < 14) {
+      suffix = alphabet[Number(value % 62n)] + suffix;
+      value /= 62n;
+    }
+    const id = prefix + suffix;
+    if (used.has(id))
+      continue;
+    used.add(id);
+    return id;
+  }
+}
+function serializeRecent(messages, parts) {
+  return messages.flatMap((message) => {
+    const owned = parts.get(message.row.id)?.map((part) => part.value) ?? [];
+    if (message.value.role === "user")
+      return [
+        `[User]: ${owned.filter((part) => part.type === "text" && !part.ignored).map((part) => part.type === "text" ? part.text : "").join(`
+
+`)}`
+      ];
+    return owned.flatMap((part) => part.type === "text" ? [`[Assistant]: ${part.text}`] : part.type === "reasoning" && part.text ? [`[Assistant reasoning]: ${part.text}`] : []);
+  }).join(`
+
+`);
+}
+function readState(db) {
+  return db.select({ value: KVTable2.value }).from(KVTable2).where(eq(KVTable2.key, MIGRATION_STATE_KEY)).get().pipe(Effect.map((row) => parseState(row?.value)), Effect.orDie);
+}
+function parseState(input) {
+  if (!input || typeof input !== "object" || !("phase" in input))
+    return;
+  if (input.phase === "completed")
+    return { phase: "completed" };
+  if (input.phase !== "sessions")
+    return;
+  if (!("cursor" in input) || input.cursor === undefined)
+    return { phase: "sessions" };
+  if (typeof input.cursor === "string")
+    return { phase: "sessions", cursor: input.cursor };
+}
+function hasLegacySessions(db) {
+  return db.get(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'session'`).pipe(Effect.map((row) => row !== undefined), Effect.orDie);
+}
+export {
+  exports_v1_migration as V1Migration,
+  layer,
+  run,
+  status,
+  transformSession
+};