alchemylab-opencode 1.0.18 → 1.0.19

package/dist/{chunk-J4KUHHYM.js → chunk-SZM3G6UF.js}

@@ -12,6 +12,12 @@ if (typeof globalThis.__export === 'undefined') { globalThis.__export = (t, a) =
 import {
   withStatics
 } from "./chunk-BI5OUHTQ.js";
+import {
+  Filesystem,
+  Glob,
+  Global,
+  Log
+} from "./chunk-2FM4SJ4F.js";
 import {
   __export,
   __reExport
@@ -36,445 +42,11 @@ async function disposeInstance(directory) {
   await Promise.allSettled([...disposers].map((disposer) => disposer(directory)));
 }
 
-// packages/opencode/src/util/filesystem.ts
-import { chmod, mkdir, readFile, stat as statFile, writeFile } from "fs/promises";
-import { createWriteStream, existsSync, statSync } from "fs";
-import { lookup } from "mime-types";
-import { realpathSync } from "fs";
-import { dirname, join, relative, resolve as pathResolve, win32 } from "path";
-import { Readable } from "stream";
-import { pipeline } from "stream/promises";
-
-// packages/opencode/src/util/glob.ts
-import { glob, globSync } from "glob";
-import { minimatch } from "minimatch";
-var Glob;
-((Glob2) => {
-  function toGlobOptions(options) {
-    return {
-      cwd: options.cwd,
-      absolute: options.absolute,
-      dot: options.dot,
-      follow: options.symlink ?? false,
-      nodir: options.include !== "all"
-    };
-  }
-  async function scan(pattern, options = {}) {
-    return glob(pattern, toGlobOptions(options));
-  }
-  Glob2.scan = scan;
-  function scanSync(pattern, options = {}) {
-    return globSync(pattern, toGlobOptions(options));
-  }
-  Glob2.scanSync = scanSync;
-  function match(pattern, filepath) {
-    return minimatch(filepath, pattern, { dot: true });
-  }
-  Glob2.match = match;
-})(Glob || (Glob = {}));
-
-// packages/opencode/src/util/filesystem.ts
-var Filesystem;
-((Filesystem2) => {
-  async function exists(p) {
-    return existsSync(p);
-  }
-  Filesystem2.exists = exists;
-  async function isDir(p) {
-    try {
-      return statSync(p).isDirectory();
-    } catch {
-      return false;
-    }
-  }
-  Filesystem2.isDir = isDir;
-  function stat(p) {
-    return statSync(p, { throwIfNoEntry: false }) ?? void 0;
-  }
-  Filesystem2.stat = stat;
-  async function statAsync(p) {
-    return statFile(p).catch((e) => {
-      if (isEnoent(e)) return void 0;
-      throw e;
-    });
-  }
-  Filesystem2.statAsync = statAsync;
-  async function size(p) {
-    const s = stat(p)?.size ?? 0;
-    return typeof s === "bigint" ? Number(s) : s;
-  }
-  Filesystem2.size = size;
-  async function readText(p) {
-    return readFile(p, "utf-8");
-  }
-  Filesystem2.readText = readText;
-  async function readJson(p) {
-    return JSON.parse(await readFile(p, "utf-8"));
-  }
-  Filesystem2.readJson = readJson;
-  async function readBytes(p) {
-    return readFile(p);
-  }
-  Filesystem2.readBytes = readBytes;
-  async function readArrayBuffer(p) {
-    const buf = await readFile(p);
-    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
-  }
-  Filesystem2.readArrayBuffer = readArrayBuffer;
-  function isEnoent(e) {
-    return typeof e === "object" && e !== null && "code" in e && e.code === "ENOENT";
-  }
-  async function write(p, content, mode) {
-    try {
-      if (mode) {
-        await writeFile(p, content, { mode });
-      } else {
-        await writeFile(p, content);
-      }
-    } catch (e) {
-      if (isEnoent(e)) {
-        await mkdir(dirname(p), { recursive: true });
-        if (mode) {
-          await writeFile(p, content, { mode });
-        } else {
-          await writeFile(p, content);
-        }
-        return;
-      }
-      throw e;
-    }
-  }
-  Filesystem2.write = write;
-  async function writeJson(p, data2, mode) {
-    return write(p, JSON.stringify(data2, null, 2), mode);
-  }
-  Filesystem2.writeJson = writeJson;
-  async function writeStream(p, stream, mode) {
-    const dir = dirname(p);
-    if (!existsSync(dir)) {
-      await mkdir(dir, { recursive: true });
-    }
-    const nodeStream = stream instanceof ReadableStream ? Readable.fromWeb(stream) : stream;
-    const writeStream2 = createWriteStream(p);
-    await pipeline(nodeStream, writeStream2);
-    if (mode) {
-      await chmod(p, mode);
-    }
-  }
-  Filesystem2.writeStream = writeStream;
-  function mimeType(p) {
-    return lookup(p) || "application/octet-stream";
-  }
-  Filesystem2.mimeType = mimeType;
-  function normalizePath(p) {
-    if (process.platform !== "win32") return p;
-    const resolved = win32.normalize(win32.resolve(windowsPath(p)));
-    try {
-      return realpathSync.native(resolved);
-    } catch {
-      return resolved;
-    }
-  }
-  Filesystem2.normalizePath = normalizePath;
-  function normalizePathPattern(p) {
-    if (process.platform !== "win32") return p;
-    if (p === "*") return p;
-    const match = p.match(/^(.*)[\\/]\*$/);
-    if (!match) return normalizePath(p);
-    const dir = /^[A-Za-z]:$/.test(match[1]) ? match[1] + "\\" : match[1];
-    return join(normalizePath(dir), "*");
-  }
-  Filesystem2.normalizePathPattern = normalizePathPattern;
-  function resolve(p) {
-    const resolved = pathResolve(windowsPath(p));
-    try {
-      return normalizePath(realpathSync(resolved));
-    } catch (e) {
-      if (isEnoent(e)) return normalizePath(resolved);
-      throw e;
-    }
-  }
-  Filesystem2.resolve = resolve;
-  function windowsPath(p) {
-    if (process.platform !== "win32") return p;
-    return p.replace(/^\/([a-zA-Z]):(?:[\\/]|$)/, (_, drive) => `${drive.toUpperCase()}:/`).replace(/^\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`).replace(/^\/cygdrive\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`).replace(/^\/mnt\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`);
-  }
-  Filesystem2.windowsPath = windowsPath;
-  function overlaps(a, b) {
-    const relA = relative(a, b);
-    const relB = relative(b, a);
-    return !relA || !relA.startsWith("..") || !relB || !relB.startsWith("..");
-  }
-  Filesystem2.overlaps = overlaps;
-  function contains(parent, child) {
-    return !relative(parent, child).startsWith("..");
-  }
-  Filesystem2.contains = contains;
-  async function findUp(target, start, stop, options) {
-    const dirs = [start];
-    let current = start;
-    while (true) {
-      if (stop === current) break;
-      const parent = dirname(current);
-      if (parent === current) break;
-      dirs.push(parent);
-      current = parent;
-    }
-    const targets = Array.isArray(target) ? target : [target];
-    const result = [];
-    for (const dir of options?.rootFirst ? dirs.toReversed() : dirs) {
-      for (const item of targets) {
-        const search = join(dir, item);
-        if (await exists(search)) result.push(search);
-      }
-    }
-    return result;
-  }
-  Filesystem2.findUp = findUp;
-  async function* up(options) {
-    const { targets, start, stop } = options;
-    let current = start;
-    while (true) {
-      for (const target of targets) {
-        const search = join(current, target);
-        if (await exists(search)) yield search;
-      }
-      if (stop === current) break;
-      const parent = dirname(current);
-      if (parent === current) break;
-      current = parent;
-    }
-  }
-  Filesystem2.up = up;
-  async function globUp(pattern, start, stop) {
-    let current = start;
-    const result = [];
-    while (true) {
-      try {
-        const matches = await Glob.scan(pattern, {
-          cwd: current,
-          absolute: true,
-          include: "file",
-          dot: true
-        });
-        result.push(...matches);
-      } catch {
-      }
-      if (stop === current) break;
-      const parent = dirname(current);
-      if (parent === current) break;
-      current = parent;
-    }
-    return result;
-  }
-  Filesystem2.globUp = globUp;
-})(Filesystem || (Filesystem = {}));
-
 // packages/opencode/src/util/iife.ts
 function iife(fn) {
   return fn();
 }
 
-// packages/opencode/src/util/log.ts
-import path2 from "path";
-import fs2 from "fs/promises";
-import { createWriteStream as createWriteStream2 } from "fs";
-
-// packages/opencode/src/global/index.ts
-import fs from "fs/promises";
-import { xdgData, xdgCache, xdgConfig, xdgState } from "xdg-basedir";
-import path from "path";
-import os from "os";
-var app = "opencode";
-var customDataDir = process.env["OPENCODE_DATA_DIR"];
-var data = customDataDir || path.join(xdgData, app);
-var globalData = path.join(xdgData, app);
-var cache = path.join(xdgCache, app);
-var config = path.join(xdgConfig, app);
-var state = customDataDir ? path.join(customDataDir, "state") : path.join(xdgState, app);
-var Global;
-((Global2) => {
-  Global2.Path = {
-    // Allow override via OPENCODE_TEST_HOME for test isolation
-    get home() {
-      return process.env.OPENCODE_TEST_HOME || os.homedir();
-    },
-    data,
-    globalData,
-    // user-global data dir (for auth, credentials — not affected by OPENCODE_DATA_DIR)
-    bin: path.join(cache, "bin"),
-    log: path.join(data, "log"),
-    cache,
-    config,
-    state
-  };
-})(Global || (Global = {}));
-await Promise.all([
-  fs.mkdir(Global.Path.data, { recursive: true }),
-  fs.mkdir(Global.Path.config, { recursive: true }),
-  fs.mkdir(Global.Path.state, { recursive: true }),
-  fs.mkdir(Global.Path.log, { recursive: true }),
-  fs.mkdir(Global.Path.bin, { recursive: true })
-]);
-var CACHE_VERSION = "21";
-var version = await Filesystem.readText(path.join(Global.Path.cache, "version")).catch(() => "0");
-if (version !== CACHE_VERSION) {
-  try {
-    const contents = await fs.readdir(Global.Path.cache);
-    await Promise.all(
-      contents.map(
-        (item) => fs.rm(path.join(Global.Path.cache, item), {
-          recursive: true,
-          force: true
-        })
-      )
-    );
-  } catch (e) {
-  }
-  await Filesystem.write(path.join(Global.Path.cache, "version"), CACHE_VERSION);
-}
-
-// packages/opencode/src/util/log.ts
-import z from "zod";
-var Log;
-((Log2) => {
-  Log2.Level = z.enum(["DEBUG", "INFO", "WARN", "ERROR"]).meta({ ref: "LogLevel", description: "Log level" });
-  const levelPriority = {
-    DEBUG: 0,
-    INFO: 1,
-    WARN: 2,
-    ERROR: 3
-  };
-  let level = "INFO";
-  function shouldLog(input) {
-    return levelPriority[input] >= levelPriority[level];
-  }
-  const loggers = /* @__PURE__ */ new Map();
-  Log2.Default = create({ service: "default" });
-  let logpath = "";
-  function file() {
-    return logpath;
-  }
-  Log2.file = file;
-  let write = (msg) => {
-    process.stderr.write(msg);
-    return msg.length;
-  };
-  async function init2(options) {
-    if (options.level) level = options.level;
-    cleanup(Global.Path.log);
-    if (options.print) return;
-    logpath = path2.join(
-      Global.Path.log,
-      options.dev ? "dev.log" : (/* @__PURE__ */ new Date()).toISOString().split(".")[0].replace(/:/g, "") + ".log"
-    );
-    await fs2.truncate(logpath).catch(() => {
-    });
-    const stream = createWriteStream2(logpath, { flags: "a" });
-    write = async (msg) => {
-      return new Promise((resolve, reject) => {
-        stream.write(msg, (err) => {
-          if (err) reject(err);
-          else resolve(msg.length);
-        });
-      });
-    };
-  }
-  Log2.init = init2;
-  async function cleanup(dir) {
-    const files = await Glob.scan("????-??-??T??????.log", {
-      cwd: dir,
-      absolute: true,
-      include: "file"
-    });
-    if (files.length <= 5) return;
-    const filesToDelete = files.slice(0, -10);
-    await Promise.all(filesToDelete.map((file2) => fs2.unlink(file2).catch(() => {
-    })));
-  }
-  function formatError(error, depth = 0) {
-    const result = error.message;
-    return error.cause instanceof Error && depth < 10 ? result + " Caused by: " + formatError(error.cause, depth + 1) : result;
-  }
-  let last = Date.now();
-  function create(tags) {
-    tags = tags || {};
-    const service = tags["service"];
-    if (service && typeof service === "string") {
-      const cached = loggers.get(service);
-      if (cached) {
-        return cached;
-      }
-    }
-    function build(message, extra) {
-      const prefix = Object.entries({
-        ...tags,
-        ...extra
-      }).filter(([_, value]) => value !== void 0 && value !== null).map(([key, value]) => {
-        const prefix2 = `${key}=`;
-        if (value instanceof Error) return prefix2 + formatError(value);
-        if (typeof value === "object") return prefix2 + JSON.stringify(value);
-        return prefix2 + value;
-      }).join(" ");
-      const next = /* @__PURE__ */ new Date();
-      const diff = next.getTime() - last;
-      last = next.getTime();
-      return [next.toISOString().split(".")[0], "+" + diff + "ms", prefix, message].filter(Boolean).join(" ") + "\n";
-    }
-    const result = {
-      debug(message, extra) {
-        if (shouldLog("DEBUG")) {
-          write("DEBUG " + build(message, extra));
-        }
-      },
-      info(message, extra) {
-        if (shouldLog("INFO")) {
-          write("INFO  " + build(message, extra));
-        }
-      },
-      error(message, extra) {
-        if (shouldLog("ERROR")) {
-          write("ERROR " + build(message, extra));
-        }
-      },
-      warn(message, extra) {
-        if (shouldLog("WARN")) {
-          write("WARN  " + build(message, extra));
-        }
-      },
-      tag(key, value) {
-        if (tags) tags[key] = value;
-        return result;
-      },
-      clone() {
-        return Log2.create({ ...tags });
-      },
-      time(message, extra) {
-        const now = Date.now();
-        result.info(message, { status: "started", ...extra });
-        function stop() {
-          result.info(message, {
-            status: "completed",
-            duration: Date.now() - now,
-            ...extra
-          });
-        }
-        return {
-          stop,
-          [Symbol.dispose]() {
-            stop();
-          }
-        };
-      }
-    };
-    if (service && typeof service === "string") {
-      loggers.set(service, result);
-    }
-    return result;
-  }
-  Log2.create = create;
-})(Log || (Log = {}));
-
 // packages/opencode/src/util/context.ts
 import { AsyncLocalStorage } from "async_hooks";
 var Context;
@@ -506,7 +78,7 @@ var Context;
 })(Context || (Context = {}));
 
 // packages/opencode/src/project/project.ts
-import z6 from "zod";
+import z5 from "zod";
 
 // packages/opencode/src/storage/db.ts
 var db_exports = {};
@@ -540,19 +112,19 @@ function lazy(fn) {
 }
 
 // packages/util/src/error.ts
-import z2 from "zod";
+import z from "zod";
 var NamedError = class _NamedError extends Error {
-  static create(name, data2) {
-    const schema = z2.object({
-      name: z2.literal(name),
-      data: data2
+  static create(name, data) {
+    const schema = z.object({
+      name: z.literal(name),
+      data
     }).meta({
       ref: name
     });
     const result = class extends _NamedError {
-      constructor(data3, options) {
+      constructor(data2, options) {
         super(name, options);
-        this.data = data3;
+        this.data = data2;
         this.name = name;
       }
       data;
@@ -576,16 +148,16 @@ var NamedError = class _NamedError extends Error {
   }
   static Unknown = _NamedError.create(
     "UnknownError",
-    z2.object({
-      message: z2.string()
+    z.object({
+      message: z.string()
     })
   );
 };
 
 // packages/opencode/src/storage/db.ts
-import z3 from "zod";
-import path3 from "path";
-import { readFileSync, readdirSync, existsSync as existsSync2 } from "fs";
+import z2 from "zod";
+import path from "path";
+import { readFileSync, readdirSync, existsSync } from "fs";
 
 // packages/opencode/src/flag/flag.ts
 import { Config } from "effect";
@@ -736,17 +308,17 @@ var InstanceState;
   });
   InstanceState2.directory = Effect.map(InstanceState2.context, (ctx) => ctx.directory);
   InstanceState2.make = (init2) => Effect.gen(function* () {
-    const cache3 = yield* ScopedCache.make({
+    const cache2 = yield* ScopedCache.make({
       capacity: Number.POSITIVE_INFINITY,
       lookup: () => Effect.gen(function* () {
         return yield* init2(yield* InstanceState2.context);
       })
     });
-    const off = registerDisposer((directory2) => Effect.runPromise(ScopedCache.invalidate(cache3, directory2)));
+    const off = registerDisposer((directory2) => Effect.runPromise(ScopedCache.invalidate(cache2, directory2)));
     yield* Effect.addFinalizer(() => Effect.sync(off));
     return {
       [TypeId]: TypeId,
-      cache: cache3
+      cache: cache2
     };
   });
   InstanceState2.get = (self) => Effect.gen(function* () {
@@ -766,8 +338,8 @@ var InstanceState;
 // packages/opencode/src/storage/db.node.ts
 import { DatabaseSync } from "node:sqlite";
 import { drizzle } from "drizzle-orm/node-sqlite";
-function init(path5) {
-  const sqlite = new DatabaseSync(path5);
+function init(path3) {
+  const sqlite = new DatabaseSync(path3);
   const db = drizzle({ client: sqlite });
   return db;
 }
@@ -775,8 +347,8 @@ function init(path5) {
 // packages/opencode/src/storage/db.ts
 var NotFoundError = NamedError.create(
   "NotFoundError",
-  z3.object({
-    message: z3.string()
+  z2.object({
+    message: z2.string()
   })
 );
 var log = Log.create({ service: "db" });
@@ -784,15 +356,15 @@ var Database;
 ((Database2) => {
   function getChannelPath() {
     if (["latest", "beta"].includes(CHANNEL) || Flag.OPENCODE_DISABLE_CHANNEL_DB)
-      return path3.join(Global.Path.data, "opencode.db");
+      return path.join(Global.Path.data, "opencode.db");
     const safe = CHANNEL.replace(/[^a-zA-Z0-9._-]/g, "-");
-    return path3.join(Global.Path.data, `opencode-${safe}.db`);
+    return path.join(Global.Path.data, `opencode-${safe}.db`);
   }
   Database2.getChannelPath = getChannelPath;
   Database2.Path = iife(() => {
     if (Flag.OPENCODE_DB) {
-      if (Flag.OPENCODE_DB === ":memory:" || path3.isAbsolute(Flag.OPENCODE_DB)) return Flag.OPENCODE_DB;
-      return path3.join(Global.Path.data, Flag.OPENCODE_DB);
+      if (Flag.OPENCODE_DB === ":memory:" || path.isAbsolute(Flag.OPENCODE_DB)) return Flag.OPENCODE_DB;
+      return path.join(Global.Path.data, Flag.OPENCODE_DB);
     }
     return getChannelPath();
   });
@@ -811,8 +383,8 @@ var Database;
   function migrations(dir) {
     const dirs = readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
     const sql = dirs.map((name) => {
-      const file = path3.join(dir, name, "migration.sql");
-      if (!existsSync2(file)) return;
+      const file = path.join(dir, name, "migration.sql");
+      if (!existsSync(file)) return;
       return {
         sql: readFileSync(file, "utf-8"),
         timestamp: time(name),
@@ -830,7 +402,7 @@ var Database;
     db.run("PRAGMA cache_size = -64000");
     db.run("PRAGMA foreign_keys = ON");
     db.run("PRAGMA wal_checkpoint(PASSIVE)");
-    const migrationsDir = path3.join(import.meta.dirname, "../packages/opencode/migration");
+    const migrationsDir = path.join(import.meta.dirname, "../packages/opencode/migration");
     if (typeof OPENCODE_MIGRATIONS !== "undefined") {
       const entries = OPENCODE_MIGRATIONS;
       if (entries.length > 0) {
@@ -996,7 +568,7 @@ var PermissionTable = sqliteTable2("permission", {
 });
 
 // packages/opencode/src/bus/bus-event.ts
-import z4 from "zod";
+import z3 from "zod";
 var BusEvent;
 ((BusEvent2) => {
   const registry = /* @__PURE__ */ new Map();
@@ -1010,11 +582,11 @@ var BusEvent;
   }
   BusEvent2.define = define;
   function payloads() {
-    return z4.discriminatedUnion(
+    return z3.discriminatedUnion(
       "type",
       registry.entries().map(([type, def]) => {
-        return z4.object({
-          type: z4.literal(type),
+        return z3.object({
+          type: z3.literal(type),
           properties: def.properties
         }).meta({
           ref: "Event." + def.type
@@ -1029,10 +601,10 @@ var BusEvent;
 
 // packages/opencode/src/util/which.ts
 import whichPkg from "which";
-import path4 from "path";
+import path2 from "path";
 function which(cmd, env) {
   const base = env?.PATH ?? env?.Path ?? process.env.PATH ?? process.env.Path ?? "";
-  const full = base ? base + path4.delimiter + Global.Path.bin : Global.Path.bin;
+  const full = base ? base + path2.delimiter + Global.Path.bin : Global.Path.bin;
   const result = whichPkg.sync(cmd, {
     nothrow: true,
     path: full,
@@ -1043,13 +615,13 @@ function which(cmd, env) {
 
 // packages/opencode/src/project/schema.ts
 import { Schema } from "effect";
-import z5 from "zod";
+import z4 from "zod";
 var projectIdSchema = Schema.String.pipe(Schema.brand("ProjectID"));
 var ProjectID = projectIdSchema.pipe(
   withStatics((schema) => ({
     global: schema.makeUnsafe("global"),
     make: (id) => schema.makeUnsafe(id),
-    zod: z5.string().pipe(z5.custom())
+    zod: z4.string().pipe(z4.custom())
   }))
 );
 
@@ -1060,10 +632,10 @@ import { NodePath as NodePath2 } from "@effect/platform-node";
 
 // packages/opencode/src/filesystem/index.ts
 import { NodeFileSystem } from "@effect/platform-node";
-import { dirname as dirname2, join as join2, relative as relative2, resolve as pathResolve2 } from "path";
-import { realpathSync as realpathSync2 } from "fs";
+import { dirname, join, relative, resolve as pathResolve } from "path";
+import { realpathSync } from "fs";
 import * as NFS from "fs/promises";
-import { lookup as lookup2 } from "mime-types";
+import { lookup } from "mime-types";
 import { Effect as Effect2, FileSystem, Layer, Schema as Schema2, ServiceMap as ServiceMap3 } from "effect";
 var AppFileSystem;
 ((AppFileSystem2) => {
@@ -1079,16 +651,16 @@ var AppFileSystem;
   AppFileSystem2.layer = Layer.effect(
     Service,
     Effect2.gen(function* () {
-      const fs3 = yield* FileSystem.FileSystem;
-      const existsSafe = Effect2.fn("FileSystem.existsSafe")(function* (path5) {
-        return yield* fs3.exists(path5).pipe(Effect2.orElseSucceed(() => false));
+      const fs = yield* FileSystem.FileSystem;
+      const existsSafe = Effect2.fn("FileSystem.existsSafe")(function* (path3) {
+        return yield* fs.exists(path3).pipe(Effect2.orElseSucceed(() => false));
       });
-      const isDir = Effect2.fn("FileSystem.isDir")(function* (path5) {
-        const info = yield* fs3.stat(path5).pipe(Effect2.catch(() => Effect2.void));
+      const isDir = Effect2.fn("FileSystem.isDir")(function* (path3) {
+        const info = yield* fs.stat(path3).pipe(Effect2.catch(() => Effect2.void));
         return info?.type === "Directory";
       });
-      const isFile = Effect2.fn("FileSystem.isFile")(function* (path5) {
-        const info = yield* fs3.stat(path5).pipe(Effect2.catch(() => Effect2.void));
+      const isFile = Effect2.fn("FileSystem.isFile")(function* (path3) {
+        const info = yield* fs.stat(path3).pipe(Effect2.catch(() => Effect2.void));
         return info?.type === "File";
       });
       const readDirectoryEntries = Effect2.fn("FileSystem.readDirectoryEntries")(function* (dirPath) {
@@ -1105,37 +677,37 @@ var AppFileSystem;
           catch: (cause) => new FileSystemError({ method: "readDirectoryEntries", cause })
         });
       });
-      const readJson = Effect2.fn("FileSystem.readJson")(function* (path5) {
-        const text3 = yield* fs3.readFileString(path5);
+      const readJson = Effect2.fn("FileSystem.readJson")(function* (path3) {
+        const text3 = yield* fs.readFileString(path3);
         return JSON.parse(text3);
       });
-      const writeJson = Effect2.fn("FileSystem.writeJson")(function* (path5, data2, mode) {
-        const content = JSON.stringify(data2, null, 2);
-        const tmp = `${path5}.tmp-${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
-        yield* fs3.writeFileString(tmp, content);
-        if (mode) yield* fs3.chmod(tmp, mode);
+      const writeJson = Effect2.fn("FileSystem.writeJson")(function* (path3, data, mode) {
+        const content = JSON.stringify(data, null, 2);
+        const tmp = `${path3}.tmp-${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
+        yield* fs.writeFileString(tmp, content);
+        if (mode) yield* fs.chmod(tmp, mode);
         yield* Effect2.tryPromise({
-          try: () => NFS.rename(tmp, path5),
+          try: () => NFS.rename(tmp, path3),
           catch: (cause) => new FileSystemError({ method: "writeJson.rename", cause })
         });
       });
-      const ensureDir = Effect2.fn("FileSystem.ensureDir")(function* (path5) {
-        yield* fs3.makeDirectory(path5, { recursive: true });
+      const ensureDir = Effect2.fn("FileSystem.ensureDir")(function* (path3) {
+        yield* fs.makeDirectory(path3, { recursive: true });
       });
-      const writeWithDirs = Effect2.fn("FileSystem.writeWithDirs")(function* (path5, content, mode) {
-        const write = typeof content === "string" ? fs3.writeFileString(path5, content) : fs3.writeFile(path5, content);
+      const writeWithDirs = Effect2.fn("FileSystem.writeWithDirs")(function* (path3, content, mode) {
+        const write = typeof content === "string" ? fs.writeFileString(path3, content) : fs.writeFile(path3, content);
         yield* write.pipe(
           Effect2.catchIf(
             (e) => e.reason._tag === "NotFound",
             () => Effect2.gen(function* () {
-              yield* fs3.makeDirectory(dirname2(path5), { recursive: true });
+              yield* fs.makeDirectory(dirname(path3), { recursive: true });
               yield* write;
             })
           )
         );
-        if (mode) yield* fs3.chmod(path5, mode);
+        if (mode) yield* fs.chmod(path3, mode);
       });
-      const glob2 = Effect2.fn("FileSystem.glob")(function* (pattern, options) {
+      const glob = Effect2.fn("FileSystem.glob")(function* (pattern, options) {
         return yield* Effect2.tryPromise({
           try: () => Glob.scan(pattern, options),
           catch: (cause) => new FileSystemError({ method: "glob", cause })
@@ -1145,10 +717,10 @@ var AppFileSystem;
         const result = [];
         let current = start;
         while (true) {
-          const search = join2(current, target);
-          if (yield* fs3.exists(search)) result.push(search);
+          const search = join(current, target);
+          if (yield* fs.exists(search)) result.push(search);
           if (stop === current) break;
-          const parent = dirname2(current);
+          const parent = dirname(current);
           if (parent === current) break;
           current = parent;
         }
@@ -1159,11 +731,11 @@ var AppFileSystem;
         let current = options.start;
         while (true) {
           for (const target of options.targets) {
-            const search = join2(current, target);
-            if (yield* fs3.exists(search)) result.push(search);
+            const search = join(current, target);
+            if (yield* fs.exists(search)) result.push(search);
           }
           if (options.stop === current) break;
-          const parent = dirname2(current);
+          const parent = dirname(current);
           if (parent === current) break;
           current = parent;
         }
@@ -1173,19 +745,19 @@ var AppFileSystem;
         const result = [];
         let current = start;
         while (true) {
-          const matches = yield* glob2(pattern, { cwd: current, absolute: true, include: "file", dot: true }).pipe(
+          const matches = yield* glob(pattern, { cwd: current, absolute: true, include: "file", dot: true }).pipe(
             Effect2.catch(() => Effect2.succeed([]))
           );
           result.push(...matches);
           if (stop === current) break;
-          const parent = dirname2(current);
+          const parent = dirname(current);
           if (parent === current) break;
           current = parent;
         }
         return result;
       });
       return Service.of({
-        ...fs3,
+        ...fs,
         existsSafe,
         isDir,
         isFile,
@@ -1197,21 +769,21 @@ var AppFileSystem;
         findUp,
         up,
         globUp,
-        glob: glob2,
+        glob,
         globMatch: Glob.match
       });
     })
   );
   AppFileSystem2.defaultLayer = AppFileSystem2.layer.pipe(Layer.provide(NodeFileSystem.layer));
   function mimeType(p) {
-    return lookup2(p) || "application/octet-stream";
+    return lookup(p) || "application/octet-stream";
   }
   AppFileSystem2.mimeType = mimeType;
   function normalizePath(p) {
     if (process.platform !== "win32") return p;
-    const resolved = pathResolve2(windowsPath(p));
+    const resolved = pathResolve(windowsPath(p));
     try {
-      return realpathSync2.native(resolved);
+      return realpathSync.native(resolved);
     } catch {
       return resolved;
     }
@@ -1223,13 +795,13 @@ var AppFileSystem;
     const match = p.match(/^(.*)[\\/]\*$/);
     if (!match) return normalizePath(p);
     const dir = /^[A-Za-z]:$/.test(match[1]) ? match[1] + "\\" : match[1];
-    return join2(normalizePath(dir), "*");
+    return join(normalizePath(dir), "*");
   }
   AppFileSystem2.normalizePathPattern = normalizePathPattern;
   function resolve(p) {
-    const resolved = pathResolve2(windowsPath(p));
+    const resolved = pathResolve(windowsPath(p));
     try {
-      return normalizePath(realpathSync2(resolved));
+      return normalizePath(realpathSync(resolved));
     } catch (e) {
       if (e?.code === "ENOENT") return normalizePath(resolved);
       throw e;
@@ -1242,13 +814,13 @@ var AppFileSystem;
   }
   AppFileSystem2.windowsPath = windowsPath;
   function overlaps(a, b) {
-    const relA = relative2(a, b);
-    const relB = relative2(b, a);
+    const relA = relative(a, b);
+    const relB = relative(b, a);
     return !relA || !relA.startsWith("..") || !relB || !relB.startsWith("..");
   }
   AppFileSystem2.overlaps = overlaps;
   function contains(parent, child) {
-    return !relative2(parent, child).startsWith("..");
+    return !relative(parent, child).startsWith("..");
   }
   AppFileSystem2.contains = contains;
 })(AppFileSystem || (AppFileSystem = {}));
@@ -1333,12 +905,12 @@ var toPlatformError = (method, err, command) => {
   });
 };
 var make2 = Effect3.gen(function* () {
-  const fs3 = yield* FileSystem2.FileSystem;
-  const path5 = yield* Path.Path;
+  const fs = yield* FileSystem2.FileSystem;
+  const path3 = yield* Path.Path;
   const cwd = Effect3.fnUntraced(function* (opts) {
     if (Predicate.isUndefined(opts.cwd)) return void 0;
-    yield* fs3.access(opts.cwd);
-    return path5.resolve(opts.cwd);
+    yield* fs.access(opts.cwd);
+    return path3.resolve(opts.cwd);
   });
   const env = (opts) => opts.extendEnv ? { ...globalThis.process.env, ...opts.env } : opts.env;
   const input = (x) => Stream.isStream(x) ? "pipe" : x;
@@ -1363,9 +935,9 @@ var make2 = Effect3.gen(function* () {
   };
   const fds = (opts) => {
     if (Predicate.isUndefined(opts.additionalFds)) return [];
-    return Object.entries(opts.additionalFds).flatMap(([name, config2]) => {
+    return Object.entries(opts.additionalFds).flatMap(([name, config]) => {
       const fd = ChildProcess.parseFdName(name);
-      return Predicate.isUndefined(fd) ? [] : [{ fd, config: config2 }];
+      return Predicate.isUndefined(fd) ? [] : [{ fd, config }];
     }).toSorted((a, b) => a.fd - b.fd);
   };
   const stdios = (sin, sout, serr, extra) => {
@@ -1642,7 +1214,7 @@ var layer2 = Layer2.effect(
 );
 var defaultLayer = layer2.pipe(Layer2.provide(NodeFileSystem2.layer), Layer2.provide(NodePath.layer));
 var rt = lazy(async () => {
-  const { makeRuntime: makeRuntime2 } = await import("./run-service-RE7EK2UK.js");
+  const { makeRuntime: makeRuntime2 } = await import("./run-service-B4BDQWO3.js");
   return makeRuntime2(ChildProcessSpawner, defaultLayer);
 });
 var runPromiseExit = async (...args) => (await rt()).runPromiseExit(...args);
@@ -1651,25 +1223,25 @@ var runPromiseExit = async (...args) => (await rt()).runPromiseExit(...args);
 var Project;
 ((Project2) => {
   const log2 = Log.create({ service: "project" });
-  Project2.Info = z6.object({
+  Project2.Info = z5.object({
     id: ProjectID.zod,
-    worktree: z6.string(),
-    vcs: z6.literal("git").optional(),
-    name: z6.string().optional(),
-    icon: z6.object({
-      url: z6.string().optional(),
-      override: z6.string().optional(),
-      color: z6.string().optional()
+    worktree: z5.string(),
+    vcs: z5.literal("git").optional(),
+    name: z5.string().optional(),
+    icon: z5.object({
+      url: z5.string().optional(),
+      override: z5.string().optional(),
+      color: z5.string().optional()
     }).optional(),
-    commands: z6.object({
-      start: z6.string().optional().describe("Startup script to run when creating a new workspace (worktree)")
+    commands: z5.object({
+      start: z5.string().optional().describe("Startup script to run when creating a new workspace (worktree)")
     }).optional(),
-    time: z6.object({
-      created: z6.number(),
-      updated: z6.number(),
-      initialized: z6.number().optional()
+    time: z5.object({
+      created: z5.number(),
+      updated: z5.number(),
+      initialized: z5.number().optional()
     }),
-    sandboxes: z6.array(z6.string())
+    sandboxes: z5.array(z5.string())
   }).meta({
     ref: "Project"
   });
@@ -1694,9 +1266,9 @@ var Project;
     };
   }
   Project2.fromRow = fromRow;
-  Project2.UpdateInput = z6.object({
+  Project2.UpdateInput = z5.object({
     projectID: ProjectID.zod,
-    name: z6.string().optional(),
+    name: z5.string().optional(),
     icon: Project2.Info.shape.icon.optional(),
     commands: Project2.Info.shape.commands.optional()
   });
@@ -1706,7 +1278,7 @@ var Project;
   Project2.layer = Layer3.effect(
     Service,
     Effect4.gen(function* () {
-      const fs3 = yield* AppFileSystem.Service;
+      const fs = yield* AppFileSystem.Service;
       const pathSvc = yield* Path3.Path;
       const spawner = yield* ChildProcessSpawner2.ChildProcessSpawner;
       const git = Effect4.fnUntraced(
@@ -1725,9 +1297,9 @@ var Project;
         Effect4.catch(() => Effect4.succeed({ code: 1, text: "", stderr: "" }))
       );
       const db = (fn) => Effect4.sync(() => Database.use(fn));
-      const emitUpdated = (data2) => Effect4.sync(
+      const emitUpdated = (data) => Effect4.sync(
         () => GlobalBus.emit("event", {
-          payload: { type: Project2.Event.Updated.type, properties: data2 }
+          payload: { type: Project2.Event.Updated.type, properties: data }
         })
       );
       const fakeVcs = Project2.Info.shape.vcs.parse(Flag.OPENCODE_FAKE_VCS);
@@ -1741,7 +1313,7 @@ var Project;
       };
       const scope = yield* Scope2.Scope;
       const readCachedProjectId = Effect4.fnUntraced(function* (dir) {
-        return yield* fs3.readFileString(pathSvc.join(dir, "opencode")).pipe(
+        return yield* fs.readFileString(pathSvc.join(dir, "opencode")).pipe(
           Effect4.map((x) => x.trim()),
           Effect4.map(ProjectID.make),
           Effect4.catch(() => Effect4.succeed(void 0))
@@ -1749,8 +1321,8 @@ var Project;
       });
       const fromDirectory2 = Effect4.fn("Project.fromDirectory")(function* (directory) {
         log2.info("fromDirectory", { directory });
-        const data2 = yield* Effect4.gen(function* () {
-          const dotgitMatches = yield* fs3.up({ targets: [".git"], start: directory }).pipe(Effect4.orDie);
+        const data = yield* Effect4.gen(function* () {
+          const dotgitMatches = yield* fs.up({ targets: [".git"], start: directory }).pipe(Effect4.orDie);
           const dotgit = dotgitMatches[0];
           if (!dotgit) {
             return {
@@ -1792,7 +1364,7 @@ var Project;
             const roots = revList.text.split("\n").filter(Boolean).map((x) => x.trim()).toSorted();
             id = roots[0] ? ProjectID.make(roots[0]) : void 0;
             if (id) {
-              yield* fs3.writeFileString(pathSvc.join(worktree, ".git", "opencode"), id).pipe(Effect4.ignore);
+              yield* fs.writeFileString(pathSvc.join(worktree, ".git", "opencode"), id).pipe(Effect4.ignore);
             }
           }
           if (!id) {
@@ -1810,11 +1382,11 @@ var Project;
           sandbox = resolveGitPath(sandbox, topLevel.text.trim());
           return { id, sandbox, worktree, vcs: "git" };
         });
-        const row = yield* db((d) => d.select().from(ProjectTable).where((0, db_exports.eq)(ProjectTable.id, data2.id)).get());
+        const row = yield* db((d) => d.select().from(ProjectTable).where((0, db_exports.eq)(ProjectTable.id, data.id)).get());
         const existing = row ? fromRow(row) : {
-          id: data2.id,
-          worktree: data2.worktree,
-          vcs: data2.vcs,
+          id: data.id,
+          worktree: data.worktree,
+          vcs: data.vcs,
           sandboxes: [],
           time: { created: Date.now(), updated: Date.now() }
         };
@@ -1822,15 +1394,15 @@ var Project;
           yield* discover2(existing).pipe(Effect4.ignore, Effect4.forkIn(scope));
         const result = {
           ...existing,
-          worktree: data2.worktree,
-          vcs: data2.vcs,
+          worktree: data.worktree,
+          vcs: data.vcs,
           time: { ...existing.time, updated: Date.now() }
         };
-        if (data2.sandbox !== result.worktree && !result.sandboxes.includes(data2.sandbox))
-          result.sandboxes.push(data2.sandbox);
+        if (data.sandbox !== result.worktree && !result.sandboxes.includes(data.sandbox))
+          result.sandboxes.push(data.sandbox);
         result.sandboxes = yield* Effect4.forEach(
           result.sandboxes,
-          (s) => fs3.exists(s).pipe(
+          (s) => fs.exists(s).pipe(
             Effect4.orDie,
             Effect4.map((exists) => exists ? s : void 0)
           ),
@@ -1864,26 +1436,26 @@ var Project;
             }
           }).run()
         );
-        if (data2.id !== ProjectID.global) {
+        if (data.id !== ProjectID.global) {
           yield* db(
-            (d) => d.update(SessionTable).set({ project_id: data2.id }).where((0, db_exports.and)((0, db_exports.eq)(SessionTable.project_id, ProjectID.global), (0, db_exports.eq)(SessionTable.directory, data2.worktree))).run()
+            (d) => d.update(SessionTable).set({ project_id: data.id }).where((0, db_exports.and)((0, db_exports.eq)(SessionTable.project_id, ProjectID.global), (0, db_exports.eq)(SessionTable.directory, data.worktree))).run()
           );
         }
         yield* emitUpdated(result);
-        return { project: result, sandbox: data2.sandbox };
+        return { project: result, sandbox: data.sandbox };
       });
       const discover2 = Effect4.fn("Project.discover")(function* (input) {
         if (input.vcs !== "git") return;
         if (input.icon?.override) return;
         if (input.icon?.url) return;
-        const matches = yield* fs3.glob("**/favicon.{ico,png,svg,jpg,jpeg,webp}", {
+        const matches = yield* fs.glob("**/favicon.{ico,png,svg,jpg,jpeg,webp}", {
           cwd: input.worktree,
           absolute: true,
           include: "file"
         }).pipe(Effect4.orDie);
         const shortest = matches.sort((a, b) => a.length - b.length)[0];
         if (!shortest) return;
-        const buffer = yield* fs3.readFile(shortest).pipe(Effect4.orDie);
+        const buffer = yield* fs.readFile(shortest).pipe(Effect4.orDie);
         const base64 = Buffer.from(buffer).toString("base64");
         const mime = AppFileSystem.mimeType(shortest);
         const url = `data:${mime};base64,${base64}`;
@@ -1907,9 +1479,9 @@ var Project;
           }).where((0, db_exports.eq)(ProjectTable.id, input.projectID)).returning().get()
         );
         if (!result) throw new Error(`Project not found: ${input.projectID}`);
-        const data2 = fromRow(result);
-        yield* emitUpdated(data2);
-        return data2;
+        const data = fromRow(result);
+        yield* emitUpdated(data);
+        return data;
       });
       const initGit2 = Effect4.fn("Project.initGit")(function* (input) {
         if (input.project.vcs === "git") return input.project;
@@ -1929,10 +1501,10 @@ var Project;
       const sandboxes2 = Effect4.fn("Project.sandboxes")(function* (id) {
         const row = yield* db((d) => d.select().from(ProjectTable).where((0, db_exports.eq)(ProjectTable.id, id)).get());
         if (!row) return [];
-        const data2 = fromRow(row);
+        const data = fromRow(row);
         return yield* Effect4.forEach(
-          data2.sandboxes,
-          (dir) => fs3.isDir(dir).pipe(
+          data.sandboxes,
+          (dir) => fs.isDir(dir).pipe(
             Effect4.orDie,
             Effect4.map((ok) => ok ? dir : void 0)
           ),
@@ -2043,12 +1615,12 @@ var State;
       }
       const exists = entries.get(init2);
       if (exists) return exists.state;
-      const state2 = init2();
+      const state = init2();
       entries.set(init2, {
-        state: state2,
+        state,
         dispose: dispose2
       });
-      return state2;
+      return state;
     };
   }
   State2.create = create;
@@ -2069,7 +1641,7 @@ var State;
     for (const [init2, entry] of entries) {
       if (!entry.dispose) continue;
       const label = typeof init2 === "function" ? init2.name : String(init2);
-      const task = Promise.resolve(entry.state).then((state2) => entry.dispose(state2)).catch((error) => {
+      const task = Promise.resolve(entry.state).then((state) => entry.dispose(state)).catch((error) => {
         log2.error("Error while disposing state:", { error, key, init: label });
       });
       tasks.push(task);
@@ -2085,7 +1657,7 @@ var State;
 
 // packages/opencode/src/project/instance.ts
 var context = Context.create("instance");
-var cache2 = /* @__PURE__ */ new Map();
+var cache = /* @__PURE__ */ new Map();
 var disposal = {
   all: void 0
 };
@@ -2119,16 +1691,16 @@ function boot(input) {
 }
 function track(directory, next) {
   const task = next.catch((error) => {
-    if (cache2.get(directory) === task) cache2.delete(directory);
+    if (cache.get(directory) === task) cache.delete(directory);
     throw error;
   });
-  cache2.set(directory, task);
+  cache.set(directory, task);
   return task;
 }
 var Instance = {
   async provide(input) {
     const directory = Filesystem.resolve(input.directory);
-    let existing = cache2.get(directory);
+    let existing = cache.get(directory);
     if (!existing) {
       Log.Default.info("creating instance", { directory });
       existing = track(
@@ -2190,7 +1762,7 @@ var Instance = {
     const directory = Filesystem.resolve(input.directory);
     Log.Default.info("reloading instance", { directory });
     await Promise.all([State.dispose(directory), disposeInstance(directory)]);
-    cache2.delete(directory);
+    cache.delete(directory);
     const next = track(directory, boot({ ...input, directory }));
     emit(directory);
     return await next;
@@ -2199,25 +1771,25 @@ var Instance = {
     const directory = Instance.directory;
     Log.Default.info("disposing instance", { directory });
     await Promise.all([State.dispose(directory), disposeInstance(directory)]);
-    cache2.delete(directory);
+    cache.delete(directory);
     emit(directory);
   },
   async disposeAll() {
     if (disposal.all) return disposal.all;
     disposal.all = iife(async () => {
       Log.Default.info("disposing all instances");
-      const entries = [...cache2.entries()];
+      const entries = [...cache.entries()];
       for (const [key, value] of entries) {
-        if (cache2.get(key) !== value) continue;
+        if (cache.get(key) !== value) continue;
         const ctx = await value.catch((error) => {
           Log.Default.warn("instance dispose failed", { key, error });
           return void 0;
         });
         if (!ctx) {
-          if (cache2.get(key) === value) cache2.delete(key);
+          if (cache.get(key) === value) cache.delete(key);
           continue;
         }
-        if (cache2.get(key) !== value) continue;
+        if (cache.get(key) !== value) continue;
         await context.provide(ctx, async () => {
           await Instance.dispose();
         });
@@ -2253,10 +1825,6 @@ function makeRuntime(service, layer3) {
 }
 
 export {
-  Glob,
-  Filesystem,
-  Global,
-  Log,
   GlobalBus,
   iife,
   lazy,
@@ -2286,4 +1854,4 @@ export {
   memoMap,
   makeRuntime
 };
-//# sourceMappingURL=chunk-J4KUHHYM.js.map
+//# sourceMappingURL=chunk-SZM3G6UF.js.map