alchemylab-opencode 1.0.19 → 1.0.21

package/dist/chunk-SZM3G6UF.js

@@ -1,1857 +0,0 @@
-// Built by esbuild from opencode-server source
-if (typeof globalThis.Bun === 'undefined') {
-  globalThis.Bun = {
-    version: '0.0.0-node-compat',
-    stdin: { async text() { const chunks = []; for await (const c of process.stdin) chunks.push(c); return Buffer.concat(chunks).toString(); } },
-    which(cmd) { try { return require('child_process').execFileSync('which', [cmd], { encoding: 'utf8' }).trim(); } catch { return null; } },
-  };
-}
-if (typeof globalThis.__name === 'undefined') { globalThis.__name = (t, n) => { Object.defineProperty(t, 'name', { value: n, configurable: true }); return t; }; }
-if (typeof globalThis.__export === 'undefined') { globalThis.__export = (t, a) => { for (const k in a) Object.defineProperty(t, k, { get: a[k], enumerable: true }); }; }
-
-import {
-  withStatics
-} from "./chunk-BI5OUHTQ.js";
-import {
-  Filesystem,
-  Glob,
-  Global,
-  Log
-} from "./chunk-2FM4SJ4F.js";
-import {
-  __export,
-  __reExport
-} from "./chunk-HORZKFCR.js";
-
-// packages/opencode/src/effect/run-service.ts
-import { Effect as Effect5, Layer as Layer4, ManagedRuntime } from "effect";
-
-// packages/opencode/src/bus/global.ts
-import { EventEmitter } from "events";
-var GlobalBus = new EventEmitter();
-
-// packages/opencode/src/effect/instance-registry.ts
-var disposers = /* @__PURE__ */ new Set();
-function registerDisposer(disposer) {
-  disposers.add(disposer);
-  return () => {
-    disposers.delete(disposer);
-  };
-}
-async function disposeInstance(directory) {
-  await Promise.allSettled([...disposers].map((disposer) => disposer(directory)));
-}
-
-// packages/opencode/src/util/iife.ts
-function iife(fn) {
-  return fn();
-}
-
-// packages/opencode/src/util/context.ts
-import { AsyncLocalStorage } from "async_hooks";
-var Context;
-((Context2) => {
-  class NotFound extends Error {
-    constructor(name) {
-      super(`No context found for ${name}`);
-      this.name = name;
-    }
-    name;
-  }
-  Context2.NotFound = NotFound;
-  function create(name) {
-    const storage = new AsyncLocalStorage();
-    return {
-      use() {
-        const result = storage.getStore();
-        if (!result) {
-          throw new NotFound(name);
-        }
-        return result;
-      },
-      provide(value, fn) {
-        return storage.run(value, fn);
-      }
-    };
-  }
-  Context2.create = create;
-})(Context || (Context = {}));
-
-// packages/opencode/src/project/project.ts
-import z5 from "zod";
-
-// packages/opencode/src/storage/db.ts
-var db_exports = {};
-__export(db_exports, {
-  Database: () => Database,
-  NotFoundError: () => NotFoundError
-});
-__reExport(db_exports, drizzle_orm_star);
-import { migrate } from "drizzle-orm/node-sqlite/migrator";
-import * as drizzle_orm_star from "drizzle-orm";
-
-// packages/opencode/src/util/lazy.ts
-function lazy(fn) {
-  let value;
-  let loaded = false;
-  const result = () => {
-    if (loaded) return value;
-    try {
-      value = fn();
-      loaded = true;
-      return value;
-    } catch (e) {
-      throw e;
-    }
-  };
-  result.reset = () => {
-    loaded = false;
-    value = void 0;
-  };
-  return result;
-}
-
-// packages/util/src/error.ts
-import z from "zod";
-var NamedError = class _NamedError extends Error {
-  static create(name, data) {
-    const schema = z.object({
-      name: z.literal(name),
-      data
-    }).meta({
-      ref: name
-    });
-    const result = class extends _NamedError {
-      constructor(data2, options) {
-        super(name, options);
-        this.data = data2;
-        this.name = name;
-      }
-      data;
-      static Schema = schema;
-      name = name;
-      static isInstance(input) {
-        return typeof input === "object" && "name" in input && input.name === name;
-      }
-      schema() {
-        return schema;
-      }
-      toObject() {
-        return {
-          name,
-          data: this.data
-        };
-      }
-    };
-    Object.defineProperty(result, "name", { value: name });
-    return result;
-  }
-  static Unknown = _NamedError.create(
-    "UnknownError",
-    z.object({
-      message: z.string()
-    })
-  );
-};
-
-// packages/opencode/src/storage/db.ts
-import z2 from "zod";
-import path from "path";
-import { readFileSync, readdirSync, existsSync } from "fs";
-
-// packages/opencode/src/flag/flag.ts
-import { Config } from "effect";
-function truthy(key) {
-  const value = process.env[key]?.toLowerCase();
-  return value === "true" || value === "1";
-}
-function falsy(key) {
-  const value = process.env[key]?.toLowerCase();
-  return value === "false" || value === "0";
-}
-var Flag;
-((Flag2) => {
-  Flag2.OPENCODE_AUTO_SHARE = truthy("OPENCODE_AUTO_SHARE");
-  Flag2.OPENCODE_AUTO_HEAP_SNAPSHOT = truthy("OPENCODE_AUTO_HEAP_SNAPSHOT");
-  Flag2.OPENCODE_GIT_BASH_PATH = process.env["OPENCODE_GIT_BASH_PATH"];
-  Flag2.OPENCODE_CONFIG = process.env["OPENCODE_CONFIG"];
-  Flag2.OPENCODE_CONFIG_CONTENT = process.env["OPENCODE_CONFIG_CONTENT"];
-  Flag2.OPENCODE_DISABLE_AUTOUPDATE = truthy("OPENCODE_DISABLE_AUTOUPDATE");
-  Flag2.OPENCODE_ALWAYS_NOTIFY_UPDATE = truthy("OPENCODE_ALWAYS_NOTIFY_UPDATE");
-  Flag2.OPENCODE_DISABLE_PRUNE = truthy("OPENCODE_DISABLE_PRUNE");
-  Flag2.OPENCODE_DISABLE_TERMINAL_TITLE = truthy("OPENCODE_DISABLE_TERMINAL_TITLE");
-  Flag2.OPENCODE_SHOW_TTFD = truthy("OPENCODE_SHOW_TTFD");
-  Flag2.OPENCODE_PERMISSION = process.env["OPENCODE_PERMISSION"];
-  Flag2.OPENCODE_DISABLE_DEFAULT_PLUGINS = truthy("OPENCODE_DISABLE_DEFAULT_PLUGINS");
-  Flag2.OPENCODE_DISABLE_LSP_DOWNLOAD = truthy("OPENCODE_DISABLE_LSP_DOWNLOAD");
-  Flag2.OPENCODE_ENABLE_EXPERIMENTAL_MODELS = truthy("OPENCODE_ENABLE_EXPERIMENTAL_MODELS");
-  Flag2.OPENCODE_DISABLE_AUTOCOMPACT = truthy("OPENCODE_DISABLE_AUTOCOMPACT");
-  Flag2.OPENCODE_DISABLE_MODELS_FETCH = truthy("OPENCODE_DISABLE_MODELS_FETCH");
-  Flag2.OPENCODE_DISABLE_MOUSE = truthy("OPENCODE_DISABLE_MOUSE");
-  Flag2.OPENCODE_DISABLE_CLAUDE_CODE = truthy("OPENCODE_DISABLE_CLAUDE_CODE");
-  Flag2.OPENCODE_DISABLE_CLAUDE_CODE_PROMPT = Flag2.OPENCODE_DISABLE_CLAUDE_CODE || truthy("OPENCODE_DISABLE_CLAUDE_CODE_PROMPT");
-  Flag2.OPENCODE_DISABLE_CLAUDE_CODE_SKILLS = Flag2.OPENCODE_DISABLE_CLAUDE_CODE || truthy("OPENCODE_DISABLE_CLAUDE_CODE_SKILLS");
-  Flag2.OPENCODE_DISABLE_EXTERNAL_SKILLS = Flag2.OPENCODE_DISABLE_CLAUDE_CODE_SKILLS || truthy("OPENCODE_DISABLE_EXTERNAL_SKILLS");
-  Flag2.OPENCODE_FAKE_VCS = process.env["OPENCODE_FAKE_VCS"];
-  Flag2.OPENCODE_SERVER_PASSWORD = process.env["OPENCODE_SERVER_PASSWORD"];
-  Flag2.OPENCODE_SERVER_USERNAME = process.env["OPENCODE_SERVER_USERNAME"];
-  Flag2.OPENCODE_ENABLE_QUESTION_TOOL = truthy("OPENCODE_ENABLE_QUESTION_TOOL");
-  Flag2.OPENCODE_EXPERIMENTAL = truthy("OPENCODE_EXPERIMENTAL");
-  Flag2.OPENCODE_EXPERIMENTAL_FILEWATCHER = Config.boolean("OPENCODE_EXPERIMENTAL_FILEWATCHER").pipe(
-    Config.withDefault(false)
-  );
-  Flag2.OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER = Config.boolean(
-    "OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER"
-  ).pipe(Config.withDefault(false));
-  Flag2.OPENCODE_EXPERIMENTAL_ICON_DISCOVERY = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_ICON_DISCOVERY");
-  const copy = process.env["OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT"];
-  Flag2.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT = copy === void 0 ? process.platform === "win32" : truthy("OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT");
-  Flag2.OPENCODE_ENABLE_EXA = truthy("OPENCODE_ENABLE_EXA") || Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_EXA");
-  Flag2.OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS = number("OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS");
-  Flag2.OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX = number("OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX");
-  Flag2.OPENCODE_EXPERIMENTAL_OXFMT = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_OXFMT");
-  Flag2.OPENCODE_EXPERIMENTAL_LSP_TY = truthy("OPENCODE_EXPERIMENTAL_LSP_TY");
-  Flag2.OPENCODE_EXPERIMENTAL_LSP_TOOL = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_LSP_TOOL");
-  Flag2.OPENCODE_DISABLE_FILETIME_CHECK = Config.boolean("OPENCODE_DISABLE_FILETIME_CHECK").pipe(
-    Config.withDefault(false)
-  );
-  Flag2.OPENCODE_EXPERIMENTAL_PLAN_MODE = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_PLAN_MODE");
-  Flag2.OPENCODE_EXPERIMENTAL_WORKSPACES = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_WORKSPACES");
-  Flag2.OPENCODE_EXPERIMENTAL_MARKDOWN = !falsy("OPENCODE_EXPERIMENTAL_MARKDOWN");
-  Flag2.OPENCODE_MODELS_URL = process.env["OPENCODE_MODELS_URL"];
-  Flag2.OPENCODE_MODELS_PATH = process.env["OPENCODE_MODELS_PATH"];
-  Flag2.OPENCODE_DISABLE_EMBEDDED_WEB_UI = truthy("OPENCODE_DISABLE_EMBEDDED_WEB_UI");
-  Flag2.OPENCODE_DB = process.env["OPENCODE_DB"];
-  Flag2.OPENCODE_DISABLE_CHANNEL_DB = truthy("OPENCODE_DISABLE_CHANNEL_DB");
-  Flag2.OPENCODE_SKIP_MIGRATIONS = truthy("OPENCODE_SKIP_MIGRATIONS");
-  Flag2.OPENCODE_STRICT_CONFIG_DEPS = truthy("OPENCODE_STRICT_CONFIG_DEPS");
-  function number(key) {
-    const value = process.env[key];
-    if (!value) return void 0;
-    const parsed = Number(value);
-    return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
-  }
-})(Flag || (Flag = {}));
-Object.defineProperty(Flag, "OPENCODE_DISABLE_PROJECT_CONFIG", {
-  get() {
-    return truthy("OPENCODE_DISABLE_PROJECT_CONFIG");
-  },
-  enumerable: true,
-  configurable: false
-});
-Object.defineProperty(Flag, "OPENCODE_TUI_CONFIG", {
-  get() {
-    return process.env["OPENCODE_TUI_CONFIG"];
-  },
-  enumerable: true,
-  configurable: false
-});
-Object.defineProperty(Flag, "OPENCODE_CONFIG_DIR", {
-  get() {
-    return process.env["OPENCODE_CONFIG_DIR"];
-  },
-  enumerable: true,
-  configurable: false
-});
-Object.defineProperty(Flag, "OPENCODE_PURE", {
-  get() {
-    return truthy("OPENCODE_PURE");
-  },
-  enumerable: true,
-  configurable: false
-});
-Object.defineProperty(Flag, "OPENCODE_PLUGIN_META_FILE", {
-  get() {
-    return process.env["OPENCODE_PLUGIN_META_FILE"];
-  },
-  enumerable: true,
-  configurable: false
-});
-Object.defineProperty(Flag, "OPENCODE_CLIENT", {
-  get() {
-    return process.env["OPENCODE_CLIENT"] ?? "cli";
-  },
-  enumerable: true,
-  configurable: false
-});
-
-// packages/opencode/src/installation/meta.ts
-var VERSION = typeof OPENCODE_VERSION === "string" ? OPENCODE_VERSION : "local";
-var CHANNEL = typeof OPENCODE_CHANNEL === "string" ? OPENCODE_CHANNEL : "local";
-
-// packages/opencode/src/effect/instance-state.ts
-import { Effect, Fiber, ScopedCache, ServiceMap as ServiceMap2 } from "effect";
-
-// packages/opencode/src/effect/instance-ref.ts
-import { ServiceMap } from "effect";
-var InstanceRef = ServiceMap.Reference("~opencode/InstanceRef", {
-  defaultValue: () => void 0
-});
-
-// packages/opencode/src/effect/instance-state.ts
-var TypeId = "~opencode/InstanceState";
-var InstanceState;
-((InstanceState2) => {
-  InstanceState2.bind = (fn) => {
-    try {
-      return Instance.bind(fn);
-    } catch (err) {
-      if (!(err instanceof Context.NotFound)) throw err;
-    }
-    const fiber = Fiber.getCurrent();
-    const ctx = fiber ? ServiceMap2.getReferenceUnsafe(fiber.services, InstanceRef) : void 0;
-    if (!ctx) return fn;
-    return ((...args) => Instance.restore(ctx, () => fn(...args)));
-  };
-  InstanceState2.context = Effect.gen(function* () {
-    return (yield* InstanceRef) ?? Instance.current;
-  });
-  InstanceState2.directory = Effect.map(InstanceState2.context, (ctx) => ctx.directory);
-  InstanceState2.make = (init2) => Effect.gen(function* () {
-    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(cache2, directory2)));
-    yield* Effect.addFinalizer(() => Effect.sync(off));
-    return {
-      [TypeId]: TypeId,
-      cache: cache2
-    };
-  });
-  InstanceState2.get = (self) => Effect.gen(function* () {
-    return yield* ScopedCache.get(self.cache, yield* InstanceState2.directory);
-  });
-  InstanceState2.use = (self, select) => Effect.map((0, InstanceState2.get)(self), select);
-  InstanceState2.useEffect = (self, select) => Effect.flatMap((0, InstanceState2.get)(self), select);
-  InstanceState2.has = (self) => Effect.gen(function* () {
-    return yield* ScopedCache.has(self.cache, yield* InstanceState2.directory);
-  });
-  InstanceState2.invalidate = (self) => Effect.gen(function* () {
-    return yield* ScopedCache.invalidate(self.cache, yield* InstanceState2.directory);
-  });
-  InstanceState2.withALS = (fn) => Effect.map(InstanceState2.context, (ctx) => Instance.restore(ctx, fn));
-})(InstanceState || (InstanceState = {}));
-
-// packages/opencode/src/storage/db.node.ts
-import { DatabaseSync } from "node:sqlite";
-import { drizzle } from "drizzle-orm/node-sqlite";
-function init(path3) {
-  const sqlite = new DatabaseSync(path3);
-  const db = drizzle({ client: sqlite });
-  return db;
-}
-
-// packages/opencode/src/storage/db.ts
-var NotFoundError = NamedError.create(
-  "NotFoundError",
-  z2.object({
-    message: z2.string()
-  })
-);
-var log = Log.create({ service: "db" });
-var Database;
-((Database2) => {
-  function getChannelPath() {
-    if (["latest", "beta"].includes(CHANNEL) || Flag.OPENCODE_DISABLE_CHANNEL_DB)
-      return path.join(Global.Path.data, "opencode.db");
-    const safe = CHANNEL.replace(/[^a-zA-Z0-9._-]/g, "-");
-    return path.join(Global.Path.data, `opencode-${safe}.db`);
-  }
-  Database2.getChannelPath = getChannelPath;
-  Database2.Path = iife(() => {
-    if (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();
-  });
-  function time(tag) {
-    const match = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/.exec(tag);
-    if (!match) return 0;
-    return Date.UTC(
-      Number(match[1]),
-      Number(match[2]) - 1,
-      Number(match[3]),
-      Number(match[4]),
-      Number(match[5]),
-      Number(match[6])
-    );
-  }
-  function migrations(dir) {
-    const dirs = readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-    const sql = dirs.map((name) => {
-      const file = path.join(dir, name, "migration.sql");
-      if (!existsSync(file)) return;
-      return {
-        sql: readFileSync(file, "utf-8"),
-        timestamp: time(name),
-        name
-      };
-    }).filter(Boolean);
-    return sql.sort((a, b) => a.timestamp - b.timestamp);
-  }
-  Database2.Client = lazy(() => {
-    log.info("opening database", { path: Database2.Path });
-    const db = init(Database2.Path);
-    db.run("PRAGMA journal_mode = WAL");
-    db.run("PRAGMA synchronous = NORMAL");
-    db.run("PRAGMA busy_timeout = 5000");
-    db.run("PRAGMA cache_size = -64000");
-    db.run("PRAGMA foreign_keys = ON");
-    db.run("PRAGMA wal_checkpoint(PASSIVE)");
-    const migrationsDir = path.join(import.meta.dirname, "../packages/opencode/migration");
-    if (typeof OPENCODE_MIGRATIONS !== "undefined") {
-      const entries = OPENCODE_MIGRATIONS;
-      if (entries.length > 0) {
-        log.info("applying migrations", { count: entries.length, mode: "bundled" });
-        if (Flag.OPENCODE_SKIP_MIGRATIONS) {
-          for (const item of entries) item.sql = "select 1;";
-        }
-        migrate(db, entries);
-      }
-    } else {
-      const entries = migrations(migrationsDir);
-      log.info("applying migrations", { count: entries.length, mode: "dev" });
-      if (!Flag.OPENCODE_SKIP_MIGRATIONS && entries.length > 0) {
-        migrate(db, { migrationsFolder: migrationsDir });
-      }
-    }
-    return db;
-  });
-  function close() {
-    (0, Database2.Client)().$client.close();
-    Database2.Client.reset();
-  }
-  Database2.close = close;
-  const ctx = Context.create("database");
-  function use(callback2) {
-    try {
-      return callback2(ctx.use().tx);
-    } catch (err) {
-      if (err instanceof Context.NotFound) {
-        const effects = [];
-        const result = ctx.provide({ effects, tx: (0, Database2.Client)() }, () => callback2((0, Database2.Client)()));
-        for (const effect3 of effects) effect3();
-        return result;
-      }
-      throw err;
-    }
-  }
-  Database2.use = use;
-  function effect2(fn) {
-    const bound = InstanceState.bind(fn);
-    try {
-      ctx.use().effects.push(bound);
-    } catch {
-      bound();
-    }
-  }
-  Database2.effect = effect2;
-  function transaction(callback2, options) {
-    try {
-      return callback2(ctx.use().tx);
-    } catch (err) {
-      if (err instanceof Context.NotFound) {
-        const effects = [];
-        const txCallback = InstanceState.bind((tx) => ctx.provide({ tx, effects }, () => callback2(tx)));
-        const result = (0, Database2.Client)().transaction(txCallback, { behavior: options?.behavior });
-        for (const effect3 of effects) effect3();
-        return result;
-      }
-      throw err;
-    }
-  }
-  Database2.transaction = transaction;
-})(Database || (Database = {}));
-
-// packages/opencode/src/project/project.sql.ts
-import { sqliteTable, text, integer as integer2 } from "drizzle-orm/sqlite-core";
-
-// packages/opencode/src/storage/schema.sql.ts
-import { integer } from "drizzle-orm/sqlite-core";
-var Timestamps = {
-  time_created: integer().notNull().$default(() => Date.now()),
-  time_updated: integer().notNull().$onUpdate(() => Date.now())
-};
-
-// packages/opencode/src/project/project.sql.ts
-var ProjectTable = sqliteTable("project", {
-  id: text().$type().primaryKey(),
-  worktree: text().notNull(),
-  vcs: text(),
-  name: text(),
-  icon_url: text(),
-  icon_color: text(),
-  ...Timestamps,
-  time_initialized: integer2(),
-  sandboxes: text({ mode: "json" }).notNull().$type(),
-  commands: text({ mode: "json" }).$type()
-});
-
-// packages/opencode/src/session/session.sql.ts
-import { sqliteTable as sqliteTable2, text as text2, integer as integer3, index, primaryKey } from "drizzle-orm/sqlite-core";
-var SessionTable = sqliteTable2(
-  "session",
-  {
-    id: text2().$type().primaryKey(),
-    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
-    workspace_id: text2().$type(),
-    parent_id: text2().$type(),
-    slug: text2().notNull(),
-    directory: text2().notNull(),
-    title: text2().notNull(),
-    version: text2().notNull(),
-    share_url: text2(),
-    summary_additions: integer3(),
-    summary_deletions: integer3(),
-    summary_files: integer3(),
-    summary_diffs: text2({ mode: "json" }).$type(),
-    revert: text2({ mode: "json" }).$type(),
-    permission: text2({ mode: "json" }).$type(),
-    ...Timestamps,
-    metadata: text2({ mode: "json" }).$type(),
-    time_compacting: integer3(),
-    time_archived: integer3()
-  },
-  (table) => [
-    index("session_project_idx").on(table.project_id),
-    index("session_workspace_idx").on(table.workspace_id),
-    index("session_parent_idx").on(table.parent_id)
-  ]
-);
-var MessageTable = sqliteTable2(
-  "message",
-  {
-    id: text2().$type().primaryKey(),
-    session_id: text2().$type().notNull().references(() => SessionTable.id, { onDelete: "cascade" }),
-    ...Timestamps,
-    data: text2({ mode: "json" }).notNull().$type()
-  },
-  (table) => [index("message_session_time_created_id_idx").on(table.session_id, table.time_created, table.id)]
-);
-var PartTable = sqliteTable2(
-  "part",
-  {
-    id: text2().$type().primaryKey(),
-    message_id: text2().$type().notNull().references(() => MessageTable.id, { onDelete: "cascade" }),
-    session_id: text2().$type().notNull(),
-    ...Timestamps,
-    data: text2({ mode: "json" }).notNull().$type()
-  },
-  (table) => [
-    index("part_message_id_id_idx").on(table.message_id, table.id),
-    index("part_session_idx").on(table.session_id)
-  ]
-);
-var TodoTable = sqliteTable2(
-  "todo",
-  {
-    session_id: text2().$type().notNull().references(() => SessionTable.id, { onDelete: "cascade" }),
-    content: text2().notNull(),
-    status: text2().notNull(),
-    priority: text2().notNull(),
-    position: integer3().notNull(),
-    ...Timestamps
-  },
-  (table) => [
-    primaryKey({ columns: [table.session_id, table.position] }),
-    index("todo_session_idx").on(table.session_id)
-  ]
-);
-var PermissionTable = sqliteTable2("permission", {
-  project_id: text2().primaryKey().references(() => ProjectTable.id, { onDelete: "cascade" }),
-  ...Timestamps,
-  data: text2({ mode: "json" }).notNull().$type()
-});
-
-// packages/opencode/src/bus/bus-event.ts
-import z3 from "zod";
-var BusEvent;
-((BusEvent2) => {
-  const registry = /* @__PURE__ */ new Map();
-  function define(type, properties) {
-    const result = {
-      type,
-      properties
-    };
-    registry.set(type, result);
-    return result;
-  }
-  BusEvent2.define = define;
-  function payloads() {
-    return z3.discriminatedUnion(
-      "type",
-      registry.entries().map(([type, def]) => {
-        return z3.object({
-          type: z3.literal(type),
-          properties: def.properties
-        }).meta({
-          ref: "Event." + def.type
-        });
-      }).toArray()
-    ).meta({
-      ref: "Event"
-    });
-  }
-  BusEvent2.payloads = payloads;
-})(BusEvent || (BusEvent = {}));
-
-// packages/opencode/src/util/which.ts
-import whichPkg from "which";
-import path2 from "path";
-function which(cmd, env) {
-  const base = env?.PATH ?? env?.Path ?? process.env.PATH ?? process.env.Path ?? "";
-  const full = base ? base + path2.delimiter + Global.Path.bin : Global.Path.bin;
-  const result = whichPkg.sync(cmd, {
-    nothrow: true,
-    path: full,
-    pathExt: env?.PATHEXT ?? env?.PathExt ?? process.env.PATHEXT ?? process.env.PathExt
-  });
-  return typeof result === "string" ? result : null;
-}
-
-// packages/opencode/src/project/schema.ts
-import { Schema } from "effect";
-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: z4.string().pipe(z4.custom())
-  }))
-);
-
-// packages/opencode/src/project/project.ts
-import { Effect as Effect4, Layer as Layer3, Path as Path3, Scope as Scope2, ServiceMap as ServiceMap4, Stream as Stream2 } from "effect";
-import { ChildProcess as ChildProcess2, ChildProcessSpawner as ChildProcessSpawner2 } from "effect/unstable/process";
-import { NodePath as NodePath2 } from "@effect/platform-node";
-
-// packages/opencode/src/filesystem/index.ts
-import { NodeFileSystem } from "@effect/platform-node";
-import { dirname, join, relative, resolve as pathResolve } from "path";
-import { realpathSync } from "fs";
-import * as NFS from "fs/promises";
-import { lookup } from "mime-types";
-import { Effect as Effect2, FileSystem, Layer, Schema as Schema2, ServiceMap as ServiceMap3 } from "effect";
-var AppFileSystem;
-((AppFileSystem2) => {
-  class FileSystemError extends Schema2.TaggedErrorClass()("FileSystemError", {
-    method: Schema2.String,
-    cause: Schema2.optional(Schema2.Defect)
-  }) {
-  }
-  AppFileSystem2.FileSystemError = FileSystemError;
-  class Service extends ServiceMap3.Service()("@opencode/FileSystem") {
-  }
-  AppFileSystem2.Service = Service;
-  AppFileSystem2.layer = Layer.effect(
-    Service,
-    Effect2.gen(function* () {
-      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* (path3) {
-        const info = yield* fs.stat(path3).pipe(Effect2.catch(() => Effect2.void));
-        return info?.type === "Directory";
-      });
-      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) {
-        return yield* Effect2.tryPromise({
-          try: async () => {
-            const entries = await NFS.readdir(dirPath, { withFileTypes: true });
-            return entries.map(
-              (e) => ({
-                name: e.name,
-                type: e.isDirectory() ? "directory" : e.isSymbolicLink() ? "symlink" : e.isFile() ? "file" : "other"
-              })
-            );
-          },
-          catch: (cause) => new FileSystemError({ method: "readDirectoryEntries", cause })
-        });
-      });
-      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* (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, path3),
-          catch: (cause) => new FileSystemError({ method: "writeJson.rename", cause })
-        });
-      });
-      const ensureDir = Effect2.fn("FileSystem.ensureDir")(function* (path3) {
-        yield* fs.makeDirectory(path3, { recursive: true });
-      });
-      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* fs.makeDirectory(dirname(path3), { recursive: true });
-              yield* write;
-            })
-          )
-        );
-        if (mode) yield* fs.chmod(path3, mode);
-      });
-      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 })
-        });
-      });
-      const findUp = Effect2.fn("FileSystem.findUp")(function* (target, start, stop) {
-        const result = [];
-        let current = start;
-        while (true) {
-          const search = join(current, target);
-          if (yield* fs.exists(search)) result.push(search);
-          if (stop === current) break;
-          const parent = dirname(current);
-          if (parent === current) break;
-          current = parent;
-        }
-        return result;
-      });
-      const up = Effect2.fn("FileSystem.up")(function* (options) {
-        const result = [];
-        let current = options.start;
-        while (true) {
-          for (const target of options.targets) {
-            const search = join(current, target);
-            if (yield* fs.exists(search)) result.push(search);
-          }
-          if (options.stop === current) break;
-          const parent = dirname(current);
-          if (parent === current) break;
-          current = parent;
-        }
-        return result;
-      });
-      const globUp = Effect2.fn("FileSystem.globUp")(function* (pattern, start, stop) {
-        const result = [];
-        let current = start;
-        while (true) {
-          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 = dirname(current);
-          if (parent === current) break;
-          current = parent;
-        }
-        return result;
-      });
-      return Service.of({
-        ...fs,
-        existsSafe,
-        isDir,
-        isFile,
-        readDirectoryEntries,
-        readJson,
-        writeJson,
-        ensureDir,
-        writeWithDirs,
-        findUp,
-        up,
-        globUp,
-        glob,
-        globMatch: Glob.match
-      });
-    })
-  );
-  AppFileSystem2.defaultLayer = AppFileSystem2.layer.pipe(Layer.provide(NodeFileSystem.layer));
-  function mimeType(p) {
-    return lookup(p) || "application/octet-stream";
-  }
-  AppFileSystem2.mimeType = mimeType;
-  function normalizePath(p) {
-    if (process.platform !== "win32") return p;
-    const resolved = pathResolve(windowsPath(p));
-    try {
-      return realpathSync.native(resolved);
-    } catch {
-      return resolved;
-    }
-  }
-  AppFileSystem2.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), "*");
-  }
-  AppFileSystem2.normalizePathPattern = normalizePathPattern;
-  function resolve(p) {
-    const resolved = pathResolve(windowsPath(p));
-    try {
-      return normalizePath(realpathSync(resolved));
-    } catch (e) {
-      if (e?.code === "ENOENT") return normalizePath(resolved);
-      throw e;
-    }
-  }
-  AppFileSystem2.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()}:/`);
-  }
-  AppFileSystem2.windowsPath = windowsPath;
-  function overlaps(a, b) {
-    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 !relative(parent, child).startsWith("..");
-  }
-  AppFileSystem2.contains = contains;
-})(AppFileSystem || (AppFileSystem = {}));
-
-// packages/opencode/src/effect/cross-spawn-spawner.ts
-import { NodeFileSystem as NodeFileSystem2, NodeSink, NodeStream } from "@effect/platform-node";
-import * as NodePath from "@effect/platform-node/NodePath";
-import * as Deferred from "effect/Deferred";
-import * as Effect3 from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as FileSystem2 from "effect/FileSystem";
-import * as Layer2 from "effect/Layer";
-import * as Path from "effect/Path";
-import * as PlatformError from "effect/PlatformError";
-import * as Predicate from "effect/Predicate";
-import * as Sink from "effect/Sink";
-import * as Stream from "effect/Stream";
-import * as ChildProcess from "effect/unstable/process/ChildProcess";
-import {
-  ChildProcessSpawner,
-  ExitCode,
-  make as makeSpawner,
-  makeHandle,
-  ProcessId
-} from "effect/unstable/process/ChildProcessSpawner";
-import * as NodeChildProcess from "node:child_process";
-import { PassThrough } from "node:stream";
-import launch from "cross-spawn";
-var toError = (err) => err instanceof globalThis.Error ? err : new globalThis.Error(String(err));
-var toTag = (err) => {
-  switch (err.code) {
-    case "ENOENT":
-      return "NotFound";
-    case "EACCES":
-      return "PermissionDenied";
-    case "EEXIST":
-      return "AlreadyExists";
-    case "EISDIR":
-      return "BadResource";
-    case "ENOTDIR":
-      return "BadResource";
-    case "EBUSY":
-      return "Busy";
-    case "ELOOP":
-      return "BadResource";
-    default:
-      return "Unknown";
-  }
-};
-var flatten = (command) => {
-  const commands = [];
-  const opts = [];
-  const walk = (cmd) => {
-    switch (cmd._tag) {
-      case "StandardCommand":
-        commands.push(cmd);
-        return;
-      case "PipedCommand":
-        walk(cmd.left);
-        opts.push(cmd.options);
-        walk(cmd.right);
-        return;
-    }
-  };
-  walk(command);
-  if (commands.length === 0) throw new Error("flatten produced empty commands array");
-  const [head, ...tail] = commands;
-  return {
-    commands: [head, ...tail],
-    opts
-  };
-};
-var toPlatformError = (method, err, command) => {
-  const cmd = flatten(command).commands.map((x) => `${x.command} ${x.args.join(" ")}`).join(" | ");
-  return PlatformError.systemError({
-    _tag: toTag(err),
-    module: "ChildProcess",
-    method,
-    pathOrDescriptor: cmd,
-    syscall: err.syscall,
-    cause: err
-  });
-};
-var make2 = Effect3.gen(function* () {
-  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* 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;
-  const output = (x) => Sink.isSink(x) ? "pipe" : x;
-  const stdin = (opts) => {
-    const cfg = { stream: "pipe", encoding: "utf-8", endOnDone: true };
-    if (Predicate.isUndefined(opts.stdin)) return cfg;
-    if (typeof opts.stdin === "string") return { ...cfg, stream: opts.stdin };
-    if (Stream.isStream(opts.stdin)) return { ...cfg, stream: opts.stdin };
-    return {
-      stream: opts.stdin.stream,
-      encoding: opts.stdin.encoding ?? cfg.encoding,
-      endOnDone: opts.stdin.endOnDone ?? cfg.endOnDone
-    };
-  };
-  const stdio = (opts, key) => {
-    const cfg = opts[key];
-    if (Predicate.isUndefined(cfg)) return { stream: "pipe" };
-    if (typeof cfg === "string") return { stream: cfg };
-    if (Sink.isSink(cfg)) return { stream: cfg };
-    return { stream: cfg.stream };
-  };
-  const fds = (opts) => {
-    if (Predicate.isUndefined(opts.additionalFds)) return [];
-    return Object.entries(opts.additionalFds).flatMap(([name, config]) => {
-      const fd = ChildProcess.parseFdName(name);
-      return Predicate.isUndefined(fd) ? [] : [{ fd, config }];
-    }).toSorted((a, b) => a.fd - b.fd);
-  };
-  const stdios = (sin, sout, serr, extra) => {
-    const pipe = (x) => process.platform === "win32" && x === "pipe" ? "overlapped" : x;
-    const arr = [
-      pipe(input(sin.stream)),
-      pipe(output(sout.stream)),
-      pipe(output(serr.stream))
-    ];
-    if (extra.length === 0) return arr;
-    const max = extra.reduce((acc, x) => Math.max(acc, x.fd), 2);
-    for (let i = 3; i <= max; i++) arr[i] = "ignore";
-    for (const x of extra) arr[x.fd] = pipe("pipe");
-    return arr;
-  };
-  const setupFds = Effect3.fnUntraced(function* (command, proc, extra) {
-    if (extra.length === 0) {
-      return {
-        getInputFd: () => Sink.drain,
-        getOutputFd: () => Stream.empty
-      };
-    }
-    const ins = /* @__PURE__ */ new Map();
-    const outs = /* @__PURE__ */ new Map();
-    for (const x of extra) {
-      const node = proc.stdio[x.fd];
-      switch (x.config.type) {
-        case "input": {
-          let sink = Sink.drain;
-          if (node && "write" in node) {
-            sink = NodeSink.fromWritable({
-              evaluate: () => node,
-              onError: (err) => toPlatformError(`fromWritable(fd${x.fd})`, toError(err), command),
-              endOnDone: true
-            });
-          }
-          if (x.config.stream) yield* Effect3.forkScoped(Stream.run(x.config.stream, sink));
-          ins.set(x.fd, sink);
-          break;
-        }
-        case "output": {
-          let stream = Stream.empty;
-          if (node && "read" in node) {
-            const tap = new PassThrough();
-            node.on("error", (err) => tap.destroy(toError(err)));
-            node.pipe(tap);
-            stream = NodeStream.fromReadable({
-              evaluate: () => tap,
-              onError: (err) => toPlatformError(`fromReadable(fd${x.fd})`, toError(err), command)
-            });
-          }
-          if (x.config.sink) stream = Stream.transduce(stream, x.config.sink);
-          outs.set(x.fd, stream);
-          break;
-        }
-      }
-    }
-    return {
-      getInputFd: (fd) => ins.get(fd) ?? Sink.drain,
-      getOutputFd: (fd) => outs.get(fd) ?? Stream.empty
-    };
-  });
-  const setupStdin = (command, proc, cfg) => Effect3.suspend(() => {
-    let sink = Sink.drain;
-    if (Predicate.isNotNull(proc.stdin)) {
-      sink = NodeSink.fromWritable({
-        evaluate: () => proc.stdin,
-        onError: (err) => toPlatformError("fromWritable(stdin)", toError(err), command),
-        endOnDone: cfg.endOnDone,
-        encoding: cfg.encoding
-      });
-    }
-    if (Stream.isStream(cfg.stream)) return Effect3.as(Effect3.forkScoped(Stream.run(cfg.stream, sink)), sink);
-    return Effect3.succeed(sink);
-  });
-  const setupOutput = (command, proc, out, err) => {
-    let stdout = proc.stdout ? NodeStream.fromReadable({
-      evaluate: () => proc.stdout,
-      onError: (cause) => toPlatformError("fromReadable(stdout)", toError(cause), command)
-    }) : Stream.empty;
-    let stderr = proc.stderr ? NodeStream.fromReadable({
-      evaluate: () => proc.stderr,
-      onError: (cause) => toPlatformError("fromReadable(stderr)", toError(cause), command)
-    }) : Stream.empty;
-    if (Sink.isSink(out.stream)) stdout = Stream.transduce(stdout, out.stream);
-    if (Sink.isSink(err.stream)) stderr = Stream.transduce(stderr, err.stream);
-    return { stdout, stderr, all: Stream.merge(stdout, stderr) };
-  };
-  const spawn = (command, opts) => Effect3.callback((resume) => {
-    const signal = Deferred.makeUnsafe();
-    const proc = launch(command.command, command.args, opts);
-    let end = false;
-    let exit;
-    proc.on("error", (err) => {
-      resume(Effect3.fail(toPlatformError("spawn", err, command)));
-    });
-    proc.on("exit", (...args) => {
-      exit = args;
-    });
-    proc.on("close", (...args) => {
-      if (end) return;
-      end = true;
-      Deferred.doneUnsafe(signal, Exit.succeed(exit ?? args));
-    });
-    proc.on("spawn", () => {
-      resume(Effect3.succeed([proc, signal]));
-    });
-    return Effect3.sync(() => {
-      proc.kill("SIGTERM");
-    });
-  });
-  const killGroup = (command, proc, signal) => {
-    if (globalThis.process.platform === "win32") {
-      return Effect3.callback((resume) => {
-        NodeChildProcess.exec(`taskkill /pid ${proc.pid} /T /F`, { windowsHide: true }, (err) => {
-          if (err) return resume(Effect3.fail(toPlatformError("kill", toError(err), command)));
-          resume(Effect3.void);
-        });
-      });
-    }
-    return Effect3.try({
-      try: () => {
-        globalThis.process.kill(-proc.pid, signal);
-      },
-      catch: (err) => toPlatformError("kill", toError(err), command)
-    });
-  };
-  const killOne = (command, proc, signal) => Effect3.suspend(() => {
-    if (proc.kill(signal)) return Effect3.void;
-    return Effect3.fail(toPlatformError("kill", new Error("Failed to kill child process"), command));
-  });
-  const timeout = (proc, command, opts) => (f) => {
-    const signal = opts?.killSignal ?? "SIGTERM";
-    if (Predicate.isUndefined(opts?.forceKillAfter)) return f(command, proc, signal);
-    return Effect3.timeoutOrElse(f(command, proc, signal), {
-      duration: opts.forceKillAfter,
-      orElse: () => f(command, proc, "SIGKILL")
-    });
-  };
-  const source = (handle, from) => {
-    const opt = from ?? "stdout";
-    switch (opt) {
-      case "stdout":
-        return handle.stdout;
-      case "stderr":
-        return handle.stderr;
-      case "all":
-        return handle.all;
-      default: {
-        const fd = ChildProcess.parseFdName(opt);
-        return Predicate.isNotUndefined(fd) ? handle.getOutputFd(fd) : handle.stdout;
-      }
-    }
-  };
-  const spawnCommand = Effect3.fnUntraced(
-    function* (command) {
-      switch (command._tag) {
-        case "StandardCommand": {
-          const sin = stdin(command.options);
-          const sout = stdio(command.options, "stdout");
-          const serr = stdio(command.options, "stderr");
-          const extra = fds(command.options);
-          const dir = yield* cwd(command.options);
-          const [proc, signal] = yield* Effect3.acquireRelease(
-            spawn(command, {
-              cwd: dir,
-              env: env(command.options),
-              stdio: stdios(sin, sout, serr, extra),
-              detached: command.options.detached ?? process.platform !== "win32",
-              shell: command.options.shell,
-              windowsHide: process.platform === "win32"
-            }),
-            Effect3.fnUntraced(function* ([proc2, signal2]) {
-              const done = yield* Deferred.isDone(signal2);
-              const kill = timeout(proc2, command, command.options);
-              if (done) {
-                const [code] = yield* Deferred.await(signal2);
-                if (process.platform === "win32") return yield* Effect3.void;
-                if (code !== 0 && Predicate.isNotNull(code)) return yield* Effect3.ignore(kill(killGroup));
-                return yield* Effect3.void;
-              }
-              const send = (s) => Effect3.catch(killGroup(command, proc2, s), () => killOne(command, proc2, s));
-              const sig = command.options.killSignal ?? "SIGTERM";
-              const attempt = send(sig).pipe(Effect3.andThen(Deferred.await(signal2)), Effect3.asVoid);
-              const escalated = command.options.forceKillAfter ? Effect3.timeoutOrElse(attempt, {
-                duration: command.options.forceKillAfter,
-                orElse: () => send("SIGKILL").pipe(Effect3.andThen(Deferred.await(signal2)), Effect3.asVoid)
-              }) : attempt;
-              return yield* Effect3.ignore(escalated);
-            })
-          );
-          const fd = yield* setupFds(command, proc, extra);
-          const out = setupOutput(command, proc, sout, serr);
-          return makeHandle({
-            pid: ProcessId(proc.pid),
-            stdin: yield* setupStdin(command, proc, sin),
-            stdout: out.stdout,
-            stderr: out.stderr,
-            all: out.all,
-            getInputFd: fd.getInputFd,
-            getOutputFd: fd.getOutputFd,
-            isRunning: Effect3.map(Deferred.isDone(signal), (done) => !done),
-            exitCode: Effect3.flatMap(Deferred.await(signal), ([code, signal2]) => {
-              if (Predicate.isNotNull(code)) return Effect3.succeed(ExitCode(code));
-              return Effect3.fail(
-                toPlatformError(
-                  "exitCode",
-                  new Error(`Process interrupted due to receipt of signal: '${signal2}'`),
-                  command
-                )
-              );
-            }),
-            kill: (opts) => {
-              const sig = opts?.killSignal ?? "SIGTERM";
-              const send = (s) => Effect3.catch(killGroup(command, proc, s), () => killOne(command, proc, s));
-              const attempt = send(sig).pipe(Effect3.andThen(Deferred.await(signal)), Effect3.asVoid);
-              if (!opts?.forceKillAfter) return attempt;
-              return Effect3.timeoutOrElse(attempt, {
-                duration: opts.forceKillAfter,
-                orElse: () => send("SIGKILL").pipe(Effect3.andThen(Deferred.await(signal)), Effect3.asVoid)
-              });
-            }
-          });
-        }
-        case "PipedCommand": {
-          const flat = flatten(command);
-          const [head, ...tail] = flat.commands;
-          let handle = spawnCommand(head);
-          for (let i = 0; i < tail.length; i++) {
-            const next = tail[i];
-            const opts = flat.opts[i] ?? {};
-            const sin = stdin(next.options);
-            const stream = Stream.unwrap(Effect3.map(handle, (x) => source(x, opts.from)));
-            const to = opts.to ?? "stdin";
-            if (to === "stdin") {
-              handle = spawnCommand(
-                ChildProcess.make(next.command, next.args, {
-                  ...next.options,
-                  stdin: { ...sin, stream }
-                })
-              );
-              continue;
-            }
-            const fd = ChildProcess.parseFdName(to);
-            if (Predicate.isUndefined(fd)) {
-              handle = spawnCommand(
-                ChildProcess.make(next.command, next.args, {
-                  ...next.options,
-                  stdin: { ...sin, stream }
-                })
-              );
-              continue;
-            }
-            handle = spawnCommand(
-              ChildProcess.make(next.command, next.args, {
-                ...next.options,
-                additionalFds: {
-                  ...next.options.additionalFds,
-                  [ChildProcess.fdName(fd)]: { type: "input", stream }
-                }
-              })
-            );
-          }
-          return yield* handle;
-        }
-      }
-    }
-  );
-  return makeSpawner(spawnCommand);
-});
-var layer2 = Layer2.effect(
-  ChildProcessSpawner,
-  make2
-);
-var defaultLayer = layer2.pipe(Layer2.provide(NodeFileSystem2.layer), Layer2.provide(NodePath.layer));
-var rt = lazy(async () => {
-  const { makeRuntime: makeRuntime2 } = await import("./run-service-B4BDQWO3.js");
-  return makeRuntime2(ChildProcessSpawner, defaultLayer);
-});
-var runPromiseExit = async (...args) => (await rt()).runPromiseExit(...args);
-
-// packages/opencode/src/project/project.ts
-var Project;
-((Project2) => {
-  const log2 = Log.create({ service: "project" });
-  Project2.Info = z5.object({
-    id: ProjectID.zod,
-    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: z5.object({
-      start: z5.string().optional().describe("Startup script to run when creating a new workspace (worktree)")
-    }).optional(),
-    time: z5.object({
-      created: z5.number(),
-      updated: z5.number(),
-      initialized: z5.number().optional()
-    }),
-    sandboxes: z5.array(z5.string())
-  }).meta({
-    ref: "Project"
-  });
-  Project2.Event = {
-    Updated: BusEvent.define("project.updated", Project2.Info)
-  };
-  function fromRow(row) {
-    const icon = row.icon_url || row.icon_color ? { url: row.icon_url ?? void 0, color: row.icon_color ?? void 0 } : void 0;
-    return {
-      id: row.id,
-      worktree: row.worktree,
-      vcs: row.vcs ? Project2.Info.shape.vcs.parse(row.vcs) : void 0,
-      name: row.name ?? void 0,
-      icon,
-      time: {
-        created: row.time_created,
-        updated: row.time_updated,
-        initialized: row.time_initialized ?? void 0
-      },
-      sandboxes: row.sandboxes,
-      commands: row.commands ?? void 0
-    };
-  }
-  Project2.fromRow = fromRow;
-  Project2.UpdateInput = z5.object({
-    projectID: ProjectID.zod,
-    name: z5.string().optional(),
-    icon: Project2.Info.shape.icon.optional(),
-    commands: Project2.Info.shape.commands.optional()
-  });
-  class Service extends ServiceMap4.Service()("@opencode/Project") {
-  }
-  Project2.Service = Service;
-  Project2.layer = Layer3.effect(
-    Service,
-    Effect4.gen(function* () {
-      const fs = yield* AppFileSystem.Service;
-      const pathSvc = yield* Path3.Path;
-      const spawner = yield* ChildProcessSpawner2.ChildProcessSpawner;
-      const git = Effect4.fnUntraced(
-        function* (args, opts) {
-          const handle = yield* spawner.spawn(
-            ChildProcess2.make("git", args, { cwd: opts?.cwd, extendEnv: true, stdin: "ignore" })
-          );
-          const [text3, stderr] = yield* Effect4.all(
-            [Stream2.mkString(Stream2.decodeText(handle.stdout)), Stream2.mkString(Stream2.decodeText(handle.stderr))],
-            { concurrency: 2 }
-          );
-          const code = yield* handle.exitCode;
-          return { code, text: text3, stderr };
-        },
-        Effect4.scoped,
-        Effect4.catch(() => Effect4.succeed({ code: 1, text: "", stderr: "" }))
-      );
-      const db = (fn) => Effect4.sync(() => Database.use(fn));
-      const emitUpdated = (data) => Effect4.sync(
-        () => GlobalBus.emit("event", {
-          payload: { type: Project2.Event.Updated.type, properties: data }
-        })
-      );
-      const fakeVcs = Project2.Info.shape.vcs.parse(Flag.OPENCODE_FAKE_VCS);
-      const resolveGitPath = (cwd, name) => {
-        if (!name) return cwd;
-        name = name.replace(/[\r\n]+$/, "");
-        if (!name) return cwd;
-        name = AppFileSystem.windowsPath(name);
-        if (pathSvc.isAbsolute(name)) return pathSvc.normalize(name);
-        return pathSvc.resolve(cwd, name);
-      };
-      const scope = yield* Scope2.Scope;
-      const readCachedProjectId = Effect4.fnUntraced(function* (dir) {
-        return yield* fs.readFileString(pathSvc.join(dir, "opencode")).pipe(
-          Effect4.map((x) => x.trim()),
-          Effect4.map(ProjectID.make),
-          Effect4.catch(() => Effect4.succeed(void 0))
-        );
-      });
-      const fromDirectory2 = Effect4.fn("Project.fromDirectory")(function* (directory) {
-        log2.info("fromDirectory", { directory });
-        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 {
-              id: ProjectID.global,
-              worktree: "/",
-              sandbox: "/",
-              vcs: fakeVcs
-            };
-          }
-          let sandbox = pathSvc.dirname(dotgit);
-          const gitBinary = yield* Effect4.sync(() => which("git"));
-          let id = yield* readCachedProjectId(dotgit);
-          if (!gitBinary) {
-            return {
-              id: id ?? ProjectID.global,
-              worktree: sandbox,
-              sandbox,
-              vcs: fakeVcs
-            };
-          }
-          const commonDir = yield* git(["rev-parse", "--git-common-dir"], { cwd: sandbox });
-          if (commonDir.code !== 0) {
-            return {
-              id: id ?? ProjectID.global,
-              worktree: sandbox,
-              sandbox,
-              vcs: fakeVcs
-            };
-          }
-          const worktree = (() => {
-            const common = resolveGitPath(sandbox, commonDir.text.trim());
-            return common === sandbox ? sandbox : pathSvc.dirname(common);
-          })();
-          if (id == null) {
-            id = yield* readCachedProjectId(pathSvc.join(worktree, ".git"));
-          }
-          if (!id) {
-            const revList = yield* git(["rev-list", "--max-parents=0", "HEAD"], { cwd: sandbox });
-            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* fs.writeFileString(pathSvc.join(worktree, ".git", "opencode"), id).pipe(Effect4.ignore);
-            }
-          }
-          if (!id) {
-            return { id: ProjectID.global, worktree: sandbox, sandbox, vcs: "git" };
-          }
-          const topLevel = yield* git(["rev-parse", "--show-toplevel"], { cwd: sandbox });
-          if (topLevel.code !== 0) {
-            return {
-              id,
-              worktree: sandbox,
-              sandbox,
-              vcs: fakeVcs
-            };
-          }
-          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, data.id)).get());
-        const existing = row ? fromRow(row) : {
-          id: data.id,
-          worktree: data.worktree,
-          vcs: data.vcs,
-          sandboxes: [],
-          time: { created: Date.now(), updated: Date.now() }
-        };
-        if (Flag.OPENCODE_EXPERIMENTAL_ICON_DISCOVERY)
-          yield* discover2(existing).pipe(Effect4.ignore, Effect4.forkIn(scope));
-        const result = {
-          ...existing,
-          worktree: data.worktree,
-          vcs: data.vcs,
-          time: { ...existing.time, updated: Date.now() }
-        };
-        if (data.sandbox !== result.worktree && !result.sandboxes.includes(data.sandbox))
-          result.sandboxes.push(data.sandbox);
-        result.sandboxes = yield* Effect4.forEach(
-          result.sandboxes,
-          (s) => fs.exists(s).pipe(
-            Effect4.orDie,
-            Effect4.map((exists) => exists ? s : void 0)
-          ),
-          { concurrency: "unbounded" }
-        ).pipe(Effect4.map((arr) => arr.filter((x) => x !== void 0)));
-        yield* db(
-          (d) => d.insert(ProjectTable).values({
-            id: result.id,
-            worktree: result.worktree,
-            vcs: result.vcs ?? null,
-            name: result.name,
-            icon_url: result.icon?.url,
-            icon_color: result.icon?.color,
-            time_created: result.time.created,
-            time_updated: result.time.updated,
-            time_initialized: result.time.initialized,
-            sandboxes: result.sandboxes,
-            commands: result.commands
-          }).onConflictDoUpdate({
-            target: ProjectTable.id,
-            set: {
-              worktree: result.worktree,
-              vcs: result.vcs ?? null,
-              name: result.name,
-              icon_url: result.icon?.url,
-              icon_color: result.icon?.color,
-              time_updated: result.time.updated,
-              time_initialized: result.time.initialized,
-              sandboxes: result.sandboxes,
-              commands: result.commands
-            }
-          }).run()
-        );
-        if (data.id !== ProjectID.global) {
-          yield* db(
-            (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: 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* 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* fs.readFile(shortest).pipe(Effect4.orDie);
-        const base64 = Buffer.from(buffer).toString("base64");
-        const mime = AppFileSystem.mimeType(shortest);
-        const url = `data:${mime};base64,${base64}`;
-        yield* update2({ projectID: input.id, icon: { url } });
-      });
-      const list2 = Effect4.fn("Project.list")(function* () {
-        return yield* db((d) => d.select().from(ProjectTable).all().map(fromRow));
-      });
-      const get2 = Effect4.fn("Project.get")(function* (id) {
-        const row = yield* db((d) => d.select().from(ProjectTable).where((0, db_exports.eq)(ProjectTable.id, id)).get());
-        return row ? fromRow(row) : void 0;
-      });
-      const update2 = Effect4.fn("Project.update")(function* (input) {
-        const result = yield* db(
-          (d) => d.update(ProjectTable).set({
-            name: input.name,
-            icon_url: input.icon?.url,
-            icon_color: input.icon?.color,
-            commands: input.commands,
-            time_updated: Date.now()
-          }).where((0, db_exports.eq)(ProjectTable.id, input.projectID)).returning().get()
-        );
-        if (!result) throw new Error(`Project not found: ${input.projectID}`);
-        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;
-        if (!(yield* Effect4.sync(() => which("git")))) throw new Error("Git is not installed");
-        const result = yield* git(["init", "--quiet"], { cwd: input.directory });
-        if (result.code !== 0) {
-          throw new Error(result.stderr.trim() || result.text.trim() || "Failed to initialize git repository");
-        }
-        const { project } = yield* fromDirectory2(input.directory);
-        return project;
-      });
-      const setInitialized2 = Effect4.fn("Project.setInitialized")(function* (id) {
-        yield* db(
-          (d) => d.update(ProjectTable).set({ time_initialized: Date.now() }).where((0, db_exports.eq)(ProjectTable.id, id)).run()
-        );
-      });
-      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 data = fromRow(row);
-        return yield* Effect4.forEach(
-          data.sandboxes,
-          (dir) => fs.isDir(dir).pipe(
-            Effect4.orDie,
-            Effect4.map((ok) => ok ? dir : void 0)
-          ),
-          { concurrency: "unbounded" }
-        ).pipe(Effect4.map((arr) => arr.filter((x) => x !== void 0)));
-      });
-      const addSandbox2 = Effect4.fn("Project.addSandbox")(function* (id, directory) {
-        const row = yield* db((d) => d.select().from(ProjectTable).where((0, db_exports.eq)(ProjectTable.id, id)).get());
-        if (!row) throw new Error(`Project not found: ${id}`);
-        const sboxes = [...row.sandboxes];
-        if (!sboxes.includes(directory)) sboxes.push(directory);
-        const result = yield* db(
-          (d) => d.update(ProjectTable).set({ sandboxes: sboxes, time_updated: Date.now() }).where((0, db_exports.eq)(ProjectTable.id, id)).returning().get()
-        );
-        if (!result) throw new Error(`Project not found: ${id}`);
-        yield* emitUpdated(fromRow(result));
-      });
-      const removeSandbox2 = Effect4.fn("Project.removeSandbox")(function* (id, directory) {
-        const row = yield* db((d) => d.select().from(ProjectTable).where((0, db_exports.eq)(ProjectTable.id, id)).get());
-        if (!row) throw new Error(`Project not found: ${id}`);
-        const sboxes = row.sandboxes.filter((s) => s !== directory);
-        const result = yield* db(
-          (d) => d.update(ProjectTable).set({ sandboxes: sboxes, time_updated: Date.now() }).where((0, db_exports.eq)(ProjectTable.id, id)).returning().get()
-        );
-        if (!result) throw new Error(`Project not found: ${id}`);
-        yield* emitUpdated(fromRow(result));
-      });
-      return Service.of({
-        fromDirectory: fromDirectory2,
-        discover: discover2,
-        list: list2,
-        get: get2,
-        update: update2,
-        initGit: initGit2,
-        setInitialized: setInitialized2,
-        sandboxes: sandboxes2,
-        addSandbox: addSandbox2,
-        removeSandbox: removeSandbox2
-      });
-    })
-  );
-  Project2.defaultLayer = Project2.layer.pipe(
-    Layer3.provide(defaultLayer),
-    Layer3.provide(AppFileSystem.defaultLayer),
-    Layer3.provide(NodePath2.layer)
-  );
-  const { runPromise } = makeRuntime(Service, Project2.defaultLayer);
-  function fromDirectory(directory) {
-    return runPromise((svc) => svc.fromDirectory(directory));
-  }
-  Project2.fromDirectory = fromDirectory;
-  function discover(input) {
-    return runPromise((svc) => svc.discover(input));
-  }
-  Project2.discover = discover;
-  function list() {
-    return Database.use(
-      (db) => db.select().from(ProjectTable).all().map((row) => fromRow(row))
-    );
-  }
-  Project2.list = list;
-  function get(id) {
-    const row = Database.use((db) => db.select().from(ProjectTable).where((0, db_exports.eq)(ProjectTable.id, id)).get());
-    if (!row) return void 0;
-    return fromRow(row);
-  }
-  Project2.get = get;
-  function setInitialized(id) {
-    Database.use(
-      (db) => db.update(ProjectTable).set({ time_initialized: Date.now() }).where((0, db_exports.eq)(ProjectTable.id, id)).run()
-    );
-  }
-  Project2.setInitialized = setInitialized;
-  function initGit(input) {
-    return runPromise((svc) => svc.initGit(input));
-  }
-  Project2.initGit = initGit;
-  function update(input) {
-    return runPromise((svc) => svc.update(input));
-  }
-  Project2.update = update;
-  function sandboxes(id) {
-    return runPromise((svc) => svc.sandboxes(id));
-  }
-  Project2.sandboxes = sandboxes;
-  function addSandbox(id, directory) {
-    return runPromise((svc) => svc.addSandbox(id, directory));
-  }
-  Project2.addSandbox = addSandbox;
-  function removeSandbox(id, directory) {
-    return runPromise((svc) => svc.removeSandbox(id, directory));
-  }
-  Project2.removeSandbox = removeSandbox;
-})(Project || (Project = {}));
-
-// packages/opencode/src/project/state.ts
-var State;
-((State2) => {
-  const log2 = Log.create({ service: "state" });
-  const recordsByKey = /* @__PURE__ */ new Map();
-  function create(root, init2, dispose2) {
-    return () => {
-      const key = root();
-      let entries = recordsByKey.get(key);
-      if (!entries) {
-        entries = /* @__PURE__ */ new Map();
-        recordsByKey.set(key, entries);
-      }
-      const exists = entries.get(init2);
-      if (exists) return exists.state;
-      const state = init2();
-      entries.set(init2, {
-        state,
-        dispose: dispose2
-      });
-      return state;
-    };
-  }
-  State2.create = create;
-  async function dispose(key) {
-    const entries = recordsByKey.get(key);
-    if (!entries) return;
-    log2.info("waiting for state disposal to complete", { key });
-    let disposalFinished = false;
-    setTimeout(() => {
-      if (!disposalFinished) {
-        log2.warn(
-          "state disposal is taking an unusually long time - if it does not complete in a reasonable time, please report this as a bug",
-          { key }
-        );
-      }
-    }, 1e4).unref();
-    const tasks = [];
-    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((state) => entry.dispose(state)).catch((error) => {
-        log2.error("Error while disposing state:", { error, key, init: label });
-      });
-      tasks.push(task);
-    }
-    await Promise.all(tasks);
-    entries.clear();
-    recordsByKey.delete(key);
-    disposalFinished = true;
-    log2.info("state disposal completed", { key });
-  }
-  State2.dispose = dispose;
-})(State || (State = {}));
-
-// packages/opencode/src/project/instance.ts
-var context = Context.create("instance");
-var cache = /* @__PURE__ */ new Map();
-var disposal = {
-  all: void 0
-};
-function emit(directory) {
-  GlobalBus.emit("event", {
-    directory,
-    payload: {
-      type: "server.instance.disposed",
-      properties: {
-        directory
-      }
-    }
-  });
-}
-function boot(input) {
-  return iife(async () => {
-    const ctx = input.project && input.worktree ? {
-      directory: input.directory,
-      worktree: input.worktree,
-      project: input.project
-    } : await Project.fromDirectory(input.directory).then(({ project, sandbox }) => ({
-      directory: input.directory,
-      worktree: sandbox,
-      project
-    }));
-    await context.provide(ctx, async () => {
-      await input.init?.();
-    });
-    return ctx;
-  });
-}
-function track(directory, next) {
-  const task = next.catch((error) => {
-    if (cache.get(directory) === task) cache.delete(directory);
-    throw error;
-  });
-  cache.set(directory, task);
-  return task;
-}
-var Instance = {
-  async provide(input) {
-    const directory = Filesystem.resolve(input.directory);
-    let existing = cache.get(directory);
-    if (!existing) {
-      Log.Default.info("creating instance", { directory });
-      existing = track(
-        directory,
-        boot({
-          directory,
-          init: input.init
-        })
-      );
-    }
-    const ctx = await existing;
-    return context.provide(ctx, async () => {
-      return input.fn();
-    });
-  },
-  get current() {
-    return context.use();
-  },
-  get directory() {
-    return context.use().directory;
-  },
-  get worktree() {
-    return context.use().worktree;
-  },
-  get project() {
-    return context.use().project;
-  },
-  /**
-   * Check if a path is within the project boundary.
-   * Returns true if path is inside Instance.directory OR Instance.worktree.
-   * Paths within the worktree but outside the working directory should not trigger external_directory permission.
-   */
-  containsPath(filepath) {
-    if (Filesystem.contains(Instance.directory, filepath)) return true;
-    if (Instance.worktree === "/") return false;
-    return Filesystem.contains(Instance.worktree, filepath);
-  },
-  /**
-   * Captures the current instance ALS context and returns a wrapper that
-   * restores it when called. Use this for callbacks that fire outside the
-   * instance async context (native addons, event emitters, timers, etc.).
-   */
-  bind(fn) {
-    const ctx = context.use();
-    return ((...args) => context.provide(ctx, () => fn(...args)));
-  },
-  /**
-   * Run a synchronous function within the given instance context ALS.
-   * Use this to bridge from Effect (where InstanceRef carries context)
-   * back to sync code that reads Instance.directory from ALS.
-   */
-  restore(ctx, fn) {
-    return context.provide(ctx, fn);
-  },
-  state(init2, dispose) {
-    return State.create(() => Instance.directory, init2, dispose);
-  },
-  async reload(input) {
-    const directory = Filesystem.resolve(input.directory);
-    Log.Default.info("reloading instance", { directory });
-    await Promise.all([State.dispose(directory), disposeInstance(directory)]);
-    cache.delete(directory);
-    const next = track(directory, boot({ ...input, directory }));
-    emit(directory);
-    return await next;
-  },
-  async dispose() {
-    const directory = Instance.directory;
-    Log.Default.info("disposing instance", { directory });
-    await Promise.all([State.dispose(directory), disposeInstance(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 = [...cache.entries()];
-      for (const [key, value] of entries) {
-        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 (cache.get(key) === value) cache.delete(key);
-          continue;
-        }
-        if (cache.get(key) !== value) continue;
-        await context.provide(ctx, async () => {
-          await Instance.dispose();
-        });
-      }
-    }).finally(() => {
-      disposal.all = void 0;
-    });
-    return disposal.all;
-  }
-};
-
-// packages/opencode/src/effect/run-service.ts
-var memoMap = Layer4.makeMemoMapUnsafe();
-function attach(effect2) {
-  try {
-    const ctx = Instance.current;
-    return Effect5.provideService(effect2, InstanceRef, ctx);
-  } catch (err) {
-    if (!(err instanceof Context.NotFound)) throw err;
-  }
-  return effect2;
-}
-function makeRuntime(service, layer3) {
-  let rt2;
-  const getRuntime = () => rt2 ??= ManagedRuntime.make(layer3, { memoMap });
-  return {
-    runSync: (fn) => getRuntime().runSync(attach(service.use(fn))),
-    runPromiseExit: (fn, options) => getRuntime().runPromiseExit(attach(service.use(fn)), options),
-    runPromise: (fn, options) => getRuntime().runPromise(attach(service.use(fn)), options),
-    runFork: (fn) => getRuntime().runFork(attach(service.use(fn))),
-    runCallback: (fn) => getRuntime().runCallback(attach(service.use(fn)))
-  };
-}
-
-export {
-  GlobalBus,
-  iife,
-  lazy,
-  NamedError,
-  Flag,
-  VERSION,
-  CHANNEL,
-  InstanceState,
-  NotFoundError,
-  Database,
-  db_exports,
-  Timestamps,
-  ProjectTable,
-  SessionTable,
-  MessageTable,
-  PartTable,
-  TodoTable,
-  PermissionTable,
-  BusEvent,
-  which,
-  ProjectID,
-  AppFileSystem,
-  defaultLayer,
-  runPromiseExit,
-  Project,
-  Instance,
-  memoMap,
-  makeRuntime
-};
-//# sourceMappingURL=chunk-SZM3G6UF.js.map