@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-nrs7ag5n.js

@@ -0,0 +1,287 @@
+import {
+  AbsolutePath2
+} from "./worktree-922hggd3.js";
+import {
+  WorktreeError2,
+  node81
+} from "./worktree-1e9w7pgh.js";
+import {
+  ID18
+} from "./worktree-pjmw00w1.js";
+import {
+  Slug2
+} from "./worktree-gebd4c9n.js";
+import {
+  Service80,
+  node85
+} from "./worktree-ecj1wrg9.js";
+import {
+  Service79,
+  node84
+} from "./worktree-vrm5r67w.js";
+import {
+  ProjectTable2
+} from "./worktree-dj2t23y0.js";
+import {
+  WorktreeTable2
+} from "./worktree-m0jqrx5p.js";
+import {
+  Service74,
+  node79
+} from "./worktree-z82wee6n.js";
+import {
+  DirectoryUnavailableError2,
+  canonical3
+} from "./worktree-th5km1p3.js";
+import {
+  make20
+} from "./worktree-kxzh2p20.js";
+import {
+  create3
+} from "./worktree-kg06axw8.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/worktree.ts
+var exports_worktree2 = {};
+__export(exports_worktree2, {
+  CreateInput: () => CreateInput3,
+  DestinationExistsError: () => DestinationExistsError2,
+  DirectoryUnavailableError: () => DirectoryUnavailableError2,
+  Event: () => Event12,
+  Info: () => Info21,
+  InvalidDirectoryError: () => InvalidDirectoryError2,
+  List: () => List2,
+  ListEntry: () => ListEntry3,
+  OperationError: () => OperationError2,
+  RefreshResult: () => RefreshResult2,
+  RemoveInput: () => RemoveInput2,
+  Service: () => Service59,
+  SourceDirectoryNotFoundError: () => SourceDirectoryNotFoundError2,
+  StrategyID: () => StrategyID2,
+  StrategyUnavailableError: () => StrategyUnavailableError2,
+  UnsupportedLocationError: () => UnsupportedLocationError2,
+  Worktree: () => exports_worktree2,
+  node: () => node64
+});
+import { Context, Effect, Layer, Schema } from "effect";
+import { and, asc, desc, eq, isNull, sql } from "drizzle-orm";
+import path from "path";
+import { FSUtil } from "@opencode/util/fs-util";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Global } from "@opencode/util/global";
+import { Worktree } from "@opencode/schema/worktree";
+import { AppProcess } from "@opencode/util/process";
+import { ChildProcess } from "effect/unstable/process";
+import { OperationError as OperationError2 } from "@opencode/schema/worktree";
+var StrategyID2 = Worktree.StrategyID;
+var CreateInput3 = Worktree.CreateInput;
+var RemoveInput2 = Worktree.RemoveInput;
+var RefreshResult2 = Schema.Struct({
+  updated: Schema.Array(AbsolutePath2),
+  removed: Schema.Array(AbsolutePath2)
+}).annotate({ identifier: "Worktree.RefreshResult" });
+var Info21 = Worktree.Info;
+var List2 = Worktree.List;
+var ListEntry3 = Worktree.ListEntry;
+
+class SourceDirectoryNotFoundError2 extends Schema.TaggedError()("Worktree.SourceDirectoryNotFoundError", { projectID: ID18, directory: Schema.optional(AbsolutePath2) }) {
+}
+
+class DestinationExistsError2 extends Schema.TaggedError()("Worktree.DestinationExistsError", { directory: AbsolutePath2 }) {
+}
+
+class InvalidDirectoryError2 extends Schema.TaggedError()("Worktree.InvalidDirectoryError", { directory: AbsolutePath2 }) {
+}
+
+class StrategyUnavailableError2 extends Schema.TaggedError()("Worktree.StrategyUnavailableError", { strategy: StrategyID2 }) {
+}
+
+class UnsupportedLocationError2 extends Schema.TaggedError()("Worktree.UnsupportedLocationError", { directory: AbsolutePath2 }) {
+}
+var Event12 = Worktree.Event;
+
+class Service59 extends Context.Service()("@opencode/v2/Worktree") {
+}
+var layer = Layer.effect(Service59, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const database = yield* Service80;
+  const db = database.db;
+  const bus = yield* Service79;
+  const processService = yield* AppProcess.Service;
+  const location = yield* Service74;
+  const global = yield* Global.Service;
+  const projectID = location.project.id;
+  const local = location.workspaceID ? Effect.fail(new UnsupportedLocationError2({ directory: location.directory })) : Effect.void;
+  const gitStrategy = yield* make20;
+  const state = create3({
+    name: "worktree",
+    initial: () => ({
+      directory: AbsolutePath2.make(path.join(global.data, "worktree", projectID.slice(0, 6))),
+      strategies: new Map([[gitStrategy.id, gitStrategy]]),
+      selected: gitStrategy.id
+    }),
+    editor: (value) => ({
+      configure: (settings) => {
+        value.directory = settings.directory;
+      },
+      add: (strategy) => {
+        value.strategies.delete(strategy.id);
+        value.strategies.set(strategy.id, strategy);
+        value.selected = strategy.id;
+      }
+    })
+  });
+  const changed = Effect.fnUntraced(function* (update) {
+    if (update)
+      yield* bus.publish(Event12.Updated, { projectID });
+  });
+  const ops = {
+    list: Effect.fnUntraced(function* () {
+      const rows = yield* db.select({ directory: WorktreeTable2.directory, strategy: WorktreeTable2.strategy }).from(WorktreeTable2).where(eq(WorktreeTable2.project_id, projectID)).orderBy(desc(WorktreeTable2.time_created), asc(WorktreeTable2.directory)).all().pipe(Effect.orDie);
+      return rows.map((row) => ({ directory: row.directory, strategy: row.strategy ?? undefined }));
+    }),
+    find: Effect.fnUntraced(function* (directory) {
+      const row = yield* db.select({ directory: WorktreeTable2.directory, strategy: WorktreeTable2.strategy }).from(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, projectID), eq(WorktreeTable2.directory, directory))).get().pipe(Effect.orDie);
+      return row ? { directory: row.directory, strategy: row.strategy ?? undefined } : undefined;
+    }),
+    create: (input, tx) => (tx ?? db).insert(WorktreeTable2).values({
+      project_id: projectID,
+      directory: input.directory,
+      strategy: input.strategy
+    }).onConflictDoUpdate({
+      target: [WorktreeTable2.project_id, WorktreeTable2.directory],
+      set: {
+        strategy: input.strategy ?? null
+      },
+      setWhere: input.replace ? undefined : input.strategy ? isNull(WorktreeTable2.strategy) : sql`false`
+    }).returning({ directory: WorktreeTable2.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined)),
+    remove: (directory, tx) => (tx ?? db).delete(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, projectID), eq(WorktreeTable2.directory, directory))).returning({ directory: WorktreeTable2.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined))
+  };
+  const source = Effect.fnUntraced(function* (input) {
+    const sourceDirectory = input ?? location.project.directory;
+    const resolved = yield* canonical3(fs, sourceDirectory);
+    if ((yield* ops.find(resolved)) === undefined)
+      return yield* new SourceDirectoryNotFoundError2({ projectID, directory: resolved });
+    return resolved;
+  });
+  const getStrategy = Effect.fnUntraced(function* (id, strategies) {
+    const found = strategies.get(id);
+    if (!found)
+      return yield* new StrategyUnavailableError2({ strategy: id });
+    return found;
+  });
+  const create = Effect.fn("Worktree.create")(function* (input = {}) {
+    yield* local;
+    const current = state.get();
+    const selected = yield* getStrategy(input.strategy ?? current.selected, current.strategies);
+    const directory = input.directory ?? current.directory;
+    const sourceDirectory = yield* source(input.from);
+    yield* fs.makeDirectory(directory, { recursive: true }).pipe(Effect.orDie);
+    const name = input.name ?? Slug2.create();
+    let suffix = 1;
+    let worktreeDirectory = AbsolutePath2.make(path.join(directory, name));
+    while (yield* fs.existsSafe(worktreeDirectory)) {
+      suffix++;
+      if (suffix > 10)
+        return yield* new DestinationExistsError2({ directory: worktreeDirectory });
+      worktreeDirectory = AbsolutePath2.make(path.join(directory, `${name}-${suffix}`));
+    }
+    const created = yield* selected.create({
+      directory: worktreeDirectory,
+      sourceDirectory,
+      branch: input.branch
+    }).pipe(Effect.mapError((error) => operationError(selected.id, "create", error)));
+    const result = { directory: yield* canonical3(fs, created.directory) };
+    if (result.directory !== (yield* canonical3(fs, worktreeDirectory)))
+      return yield* new InvalidDirectoryError2({ directory: result.directory });
+    yield* changed(yield* ops.create({
+      directory: result.directory,
+      strategy: selected.id,
+      replace: true
+    }));
+    const project = yield* db.select({ commands: ProjectTable2.commands }).from(ProjectTable2).where(eq(ProjectTable2.id, projectID)).get().pipe(Effect.orDie);
+    const command = project?.commands?.start?.trim();
+    if (command) {
+      const windows = process.platform === "win32";
+      yield* processService.run(ChildProcess.make(windows ? command : "bash", windows ? [] : ["-lc", command], {
+        cwd: result.directory,
+        env: {
+          OPENCODE_WORKTREE_BASE: sourceDirectory,
+          OPENCODE_WORKTREE_PATH: result.directory
+        },
+        extendEnv: true,
+        stdin: "ignore",
+        shell: windows
+      })).pipe(Effect.flatMap(AppProcess.requireSuccess));
+    }
+    return result;
+  });
+  const remove = Effect.fn("Worktree.remove")(function* (input) {
+    yield* local;
+    const worktreeDirectory = yield* canonical3(fs, input.directory);
+    const stored = yield* ops.find(worktreeDirectory);
+    if (!stored?.strategy)
+      return yield* new InvalidDirectoryError2({ directory: worktreeDirectory });
+    const strategy = yield* getStrategy(StrategyID2.make(stored.strategy), state.get().strategies);
+    yield* strategy.remove({
+      directory: worktreeDirectory,
+      force: input.force
+    }).pipe(Effect.mapError((error) => operationError(strategy.id, "remove", error)));
+    yield* changed(yield* ops.remove(worktreeDirectory));
+  });
+  const refresh = Effect.fn("Worktree.refresh")(function* () {
+    yield* local;
+    const stored = yield* ops.list();
+    const checked = yield* Effect.forEach(stored, (item) => fs.isDir(item.directory).pipe(Effect.map((exists) => ({ ...item, exists }))), { concurrency: "unbounded" });
+    const strategies = Array.from(state.get().strategies.values()).toReversed();
+    const discovered = new Map;
+    if (checked.some((item) => item.directory === location.project.directory && item.exists)) {
+      for (const strategy of strategies) {
+        const entries = yield* strategy.list(location.project.directory).pipe(Effect.mapError((error) => operationError(strategy.id, "list", error)), Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.succeed([])));
+        for (const entry of entries) {
+          const directory = yield* canonical3(fs, entry.directory).pipe(Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.undefined));
+          if (!directory || discovered.has(directory))
+            continue;
+          discovered.set(directory, {
+            directory,
+            strategy: entry.type === "worktree" ? strategy.id : undefined
+          });
+        }
+      }
+    }
+    const removed = checked.filter((item) => !item.exists).map((item) => item.directory);
+    const changes = yield* db.transaction((tx) => Effect.all({
+      updated: Effect.filter(Array.from(discovered.values()), (item) => ops.create(item, tx)).pipe(Effect.map((items) => items.map((item) => item.directory))),
+      removed: Effect.filter(removed, (directory) => ops.remove(directory, tx))
+    })).pipe(Effect.orDie);
+    yield* changed(changes.updated.length > 0 || changes.removed.length > 0);
+    return changes;
+  });
+  return Service59.of({
+    transform: state.transform,
+    reload: state.reload,
+    list: Effect.fn("Worktree.list")(function* () {
+      yield* refresh();
+      return yield* ops.list();
+    }),
+    create,
+    remove,
+    refresh
+  });
+}));
+var node64 = makeLocationNode({
+  service: Service59,
+  layer,
+  deps: [FSUtil.node, node81, node84, node85, AppProcess.node, node79, Global.node]
+});
+function operationError(strategy, operation, error) {
+  if (error instanceof WorktreeError2 || error instanceof DirectoryUnavailableError2 || error instanceof Worktree.OperationError)
+    return error;
+  return new Worktree.OperationError({
+    message: `Worktree strategy ${strategy} failed to ${operation}: ${error instanceof globalThis.Error ? error.message : String(error)}`
+  });
+}
+
+export { StrategyID2, CreateInput3, RemoveInput2, RefreshResult2, Info21, List2, ListEntry3, SourceDirectoryNotFoundError2, DestinationExistsError2, InvalidDirectoryError2, StrategyUnavailableError2, UnsupportedLocationError2, Event12, Service59, node64, exports_worktree2, OperationError2 };

package/dist/chunks/worktree-nsx3nvvw.js

@@ -0,0 +1,63 @@
+import {
+  makeUnsafe2
+} from "./worktree-y71avatq.js";
+import {
+  Service52,
+  node55
+} from "./worktree-pr7ch8ks.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/file-mutation.ts
+var exports_file_mutation = {};
+__export(exports_file_mutation, {
+  FileMutation: () => exports_file_mutation,
+  Service: () => Service51,
+  node: () => node54,
+  readText: () => readText2,
+  syncTextBom: () => syncTextBom2
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Bom } from "@opencode/util/bom";
+class Service51 extends Context.Service()("@opencode/FileMutation") {
+}
+var readText2 = Effect.fn("FileMutation.readText")(function* (files, target) {
+  return Bom.decodeBytes((yield* files.read(target)).bytes);
+});
+var syncTextBom2 = Effect.fn("FileMutation.syncTextBom")(function* (files, target, bom) {
+  const synced = Bom.syncBytes((yield* files.read(target)).bytes, bom);
+  if (synced.bytes)
+    yield* files.write(target, synced.bytes);
+  return synced.text;
+});
+var transactionLocks = makeUnsafe2();
+var layer = Layer.effect(Service51, Effect.gen(function* () {
+  const environment = yield* Service52;
+  const locks = makeUnsafe2();
+  const withLock = (targets) => (effect) => [...new Set(targets.map(FSUtil.resolve))].sort().reduceRight((result, target) => transactionLocks.withLock(target)(result), effect);
+  const withTargetLock = (target) => (effect) => locks.withLock(target.absolute)(Effect.uninterruptible(effect));
+  const writeResult = (target, existed) => ({
+    operation: "write",
+    target: target.absolute,
+    resource: target.resource,
+    existed
+  });
+  const write = Effect.fn("FileMutation.write")((input) => withTargetLock(input.target)(Effect.gen(function* () {
+    const existed = yield* environment.files.stat(input.target.absolute).pipe(Effect.as(true), Effect.catchTag("Environment.NotFound", () => Effect.succeed(false)));
+    yield* environment.files.write(input.target.absolute, typeof input.content === "string" ? new TextEncoder().encode(input.content) : input.content);
+    return writeResult(input.target, existed);
+  })));
+  const writeTextPreservingBom = Effect.fn("FileMutation.writeTextPreservingBom")((input) => withTargetLock(input.target)(Effect.gen(function* () {
+    const next = Bom.split(input.content);
+    const current = yield* environment.files.read(input.target.absolute, { offset: 0, length: 3 }).pipe(Effect.map((result) => result.bytes), Effect.catchTag("Environment.NotFound", () => Effect.undefined));
+    yield* environment.files.write(input.target.absolute, new TextEncoder().encode(Bom.join(next.text, Boolean(current && Bom.has(current)) || next.bom)));
+    return writeResult(input.target, current !== undefined);
+  })));
+  return Service51.of({ withLock, write, writeTextPreservingBom });
+}));
+var node54 = makeLocationNode({ service: Service51, layer, deps: [node55] });
+
+export { Service51, readText2, syncTextBom2, node54, exports_file_mutation };

package/dist/chunks/worktree-nze8c8vz.js

@@ -0,0 +1,46 @@
+import {
+  Service54
+} from "./worktree-r82b328h.js";
+import {
+  Service68
+} from "./worktree-nzwzy72p.js";
+import {
+  observe2
+} from "./worktree-qsdy395h.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/config/plugin/image.ts
+var exports_image = {};
+__export(exports_image, {
+  ConfigImagePlugin: () => exports_image,
+  Plugin: () => Plugin27
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect } from "effect";
+var Plugin27 = define({
+  id: "opencode.config.image",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service54;
+    const image = yield* Service68;
+    const loaded = yield* observe2(config, ctx.event, image.reload());
+    yield* image.transform((editor) => {
+      for (const entry of loaded.entries) {
+        if (entry.type !== "document")
+          continue;
+        const configured = entry.info.media?.image;
+        if (!configured)
+          continue;
+        editor.configure({
+          ...configured.auto_resize === undefined ? {} : { autoResize: configured.auto_resize },
+          ...configured.max_width === undefined ? {} : { maxWidth: configured.max_width },
+          ...configured.max_height === undefined ? {} : { maxHeight: configured.max_height },
+          ...configured.max_base64_bytes === undefined ? {} : { maxBase64Bytes: configured.max_base64_bytes }
+        });
+      }
+    });
+  })
+});
+
+export { Plugin27, exports_image };

package/dist/chunks/worktree-nzwzy72p.js

@@ -0,0 +1,81 @@
+import {
+  create3
+} from "./worktree-kg06axw8.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/image.ts
+var exports_image2 = {};
+__export(exports_image2, {
+  DecodeError: () => DecodeError2,
+  Image: () => exports_image2,
+  ResizerUnavailableError: () => ResizerUnavailableError2,
+  Service: () => Service68,
+  SizeError: () => SizeError2,
+  node: () => node73
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+class ResizerUnavailableError2 extends Schema.TaggedError()("Image.ResizerUnavailableError", {}) {
+}
+
+class DecodeError2 extends Schema.TaggedError()("Image.DecodeError", {
+  resource: Schema.String
+}) {
+  get message() {
+    return `Image could not be decoded: ${this.resource}`;
+  }
+}
+
+class SizeError2 extends Schema.TaggedError()("Image.SizeError", {
+  resource: Schema.String,
+  width: Schema.Number,
+  height: Schema.Number,
+  bytes: Schema.Number,
+  maxWidth: Schema.Number,
+  maxHeight: Schema.Number,
+  maxBytes: Schema.Number
+}) {
+  get message() {
+    return `Image ${this.resource} is ${this.width}x${this.height} with base64 size ${this.bytes}, exceeding configured limits ${this.maxWidth}x${this.maxHeight}/${this.maxBytes} bytes`;
+  }
+}
+
+class Service68 extends Context.Service()("@opencode/Image") {
+}
+var layer = Layer.effect(Service68, Effect.gen(function* () {
+  const state = create3({
+    name: "image",
+    initial: () => ({
+      autoResize: true,
+      maxWidth: 2000,
+      maxHeight: 2000,
+      maxBase64Bytes: 5 * 1024 * 1024
+    }),
+    editor: (editor) => ({
+      configure: (limits) => {
+        if (limits.autoResize !== undefined)
+          editor.autoResize = limits.autoResize;
+        if (limits.maxWidth !== undefined)
+          editor.maxWidth = limits.maxWidth;
+        if (limits.maxHeight !== undefined)
+          editor.maxHeight = limits.maxHeight;
+        if (limits.maxBase64Bytes !== undefined)
+          editor.maxBase64Bytes = limits.maxBase64Bytes;
+      }
+    })
+  });
+  const loadAdapter = yield* Effect.cached(Effect.tryPromise({
+    try: () => import("../image/photon.js"),
+    catch: () => new ResizerUnavailableError2
+  }).pipe(Effect.flatMap((adapter) => adapter.make)));
+  const normalize = Effect.fn("Image.normalize")(function* (resource, content) {
+    const normalize = yield* loadAdapter;
+    return yield* normalize(resource, content, state.get());
+  });
+  return Service68.of({ transform: state.transform, reload: state.reload, normalize });
+}));
+var node73 = makeLocationNode({ service: Service68, layer, deps: [] });
+
+export { ResizerUnavailableError2, DecodeError2, SizeError2, Service68, node73, exports_image2 };

package/dist/chunks/worktree-p0cja4mf.js

@@ -0,0 +1,35 @@
+import {
+  ID12
+} from "./worktree-9qn3qky1.js";
+import {
+  loadSDKFactory2
+} from "./worktree-hjbc5kem.js";
+
+// src/plugin/provider/sap-ai-core.ts
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+import { Npm } from "@opencode/util/npm";
+var SapAICorePlugin2 = define({
+  id: "opencode.provider.sap.ai.core",
+  effect: Effect.fn(function* (ctx) {
+    const npm = yield* Npm.Service;
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== ID12.make("sap-ai-core"))
+        return;
+      const serviceKey = process.env.AICORE_SERVICE_KEY ?? (typeof evt.options.serviceKey === "string" ? evt.options.serviceKey : undefined);
+      if (serviceKey && !process.env.AICORE_SERVICE_KEY)
+        process.env.AICORE_SERVICE_KEY = serviceKey;
+      const factory = yield* loadSDKFactory2(npm, evt.package);
+      if (typeof factory !== "function")
+        return yield* Effect.die(new Error(`Package ${evt.package} provider factory export is not callable`));
+      evt.sdk = factory(serviceKey ? { deploymentId: process.env.AICORE_DEPLOYMENT_ID, resourceGroup: process.env.AICORE_RESOURCE_GROUP } : {});
+    }));
+    yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== ID12.make("sap-ai-core"))
+        return;
+      evt.language = evt.sdk(evt.model.modelID ?? evt.model.id);
+    }));
+  })
+});
+
+export { SapAICorePlugin2 };

package/dist/chunks/worktree-p72z5xx6.js

@@ -0,0 +1,64 @@
+import {
+  AbsolutePath2,
+  RelativePath2
+} from "./worktree-922hggd3.js";
+import {
+  SessionSchema2
+} from "./worktree-2f04pwep.js";
+
+// src/session/info.ts
+import { DateTime, Schema } from "effect";
+import { Agent } from "@opencode/schema/agent";
+import { Location } from "@opencode/schema/location";
+import { Model } from "@opencode/schema/model";
+import { Project } from "@opencode/schema/project";
+import { Provider } from "@opencode/schema/provider";
+import { Workspace } from "@opencode/schema/workspace";
+import { PersistedRevert } from "@opencode/schema/session-revert";
+import { Money } from "@opencode/schema/money";
+var decodeRevert = Schema.decodeUnknownSync(PersistedRevert);
+function fromRow2(row) {
+  return SessionSchema2.Info.make({
+    id: SessionSchema2.ID.make(row.id),
+    projectID: Project.ID.make(row.project_id),
+    title: row.title ?? undefined,
+    parentID: row.parent_id ? SessionSchema2.ID.make(row.parent_id) : undefined,
+    fork: row.fork_session_id && row.fork_boundary ? {
+      sessionID: SessionSchema2.ID.make(row.fork_session_id),
+      boundary: row.fork_boundary
+    } : undefined,
+    agent: row.agent ? Agent.ID.make(row.agent) : undefined,
+    model: row.model ? {
+      id: Model.ID.make(row.model.id),
+      providerID: Provider.ID.make(row.model.providerID),
+      variant: Model.VariantID.make(row.model.variant ?? "default")
+    } : undefined,
+    cost: Money.USD.make(row.cost),
+    tokens: {
+      input: row.tokens_input,
+      output: row.tokens_output,
+      reasoning: row.tokens_reasoning,
+      cache: {
+        read: row.tokens_cache_read,
+        write: row.tokens_cache_write
+      }
+    },
+    location: Location.Ref.make({
+      directory: AbsolutePath2.make(row.directory),
+      workspaceID: row.workspace_id ? Workspace.ID.make(row.workspace_id) : undefined
+    }),
+    subpath: row.path ? RelativePath2.make(row.path) : undefined,
+    metadata: row.metadata ?? undefined,
+    revert: row.revert ? decodeRevert(row.revert) : undefined,
+    outcome: row.idle_outcome ?? undefined,
+    time: {
+      created: DateTime.makeUnsafe(row.time_created),
+      updated: DateTime.makeUnsafe(row.time_updated),
+      idle: row.time_idle === null ? undefined : DateTime.makeUnsafe(row.time_idle),
+      viewed: row.time_viewed === null ? undefined : DateTime.makeUnsafe(row.time_viewed),
+      archived: row.time_archived ? DateTime.makeUnsafe(row.time_archived) : undefined
+    }
+  });
+}
+
+export { fromRow2 };