@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-f4cp4g4a.js

@@ -0,0 +1,17 @@
+// src/database/migration/20260622170816_reset_v2_session_state.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260622170816_reset_v2_session_state",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DELETE FROM \`session_context_epoch\`;`);
+      yield* tx.run(`DELETE FROM \`session_input\`;`);
+      yield* tx.run(`DELETE FROM \`session_message\`;`);
+      yield* tx.run(`DELETE FROM \`event\`;`);
+      yield* tx.run(`DELETE FROM \`event_sequence\`;`);
+    });
+  }
+};
+var _20260622170816_reset_v2_session_state_default = migration;
+
+export { _20260622170816_reset_v2_session_state_default };

package/dist/chunks/ripgrep-f84sxdqn.js

@@ -0,0 +1,49 @@
+// src/database/drizzle/up-migrations/utils.ts
+var MIGRATIONS_TABLE_VERSIONS = {
+  sqlite: 1,
+  pg: 1,
+  effect: 1,
+  mysql: 1,
+  mssql: 1,
+  cockroach: 1,
+  singlestore: 1
+};
+var GET_VERSION_FOR = {
+  mysql: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  },
+  pg: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  },
+  effect: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  },
+  mssql: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  },
+  cockroach: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  },
+  singlestore: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  },
+  sqlite: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  }
+};
+
+export { MIGRATIONS_TABLE_VERSIONS, GET_VERSION_FOR };

package/dist/chunks/ripgrep-faypg4r1.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260428004200_add_session_path.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260428004200_add_session_path",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`path\` text;`);
+    });
+  }
+};
+var _20260428004200_add_session_path_default = migration;
+
+export { _20260428004200_add_session_path_default };

package/dist/chunks/ripgrep-fb5qgyky.js

@@ -0,0 +1,272 @@
+import {
+  upgradeIfNeeded
+} from "./ripgrep-hsyk7kfz.js";
+import {
+  SQLiteEffectDatabase
+} from "./ripgrep-28q8yd1e.js";
+import {
+  mapResultRow
+} from "./ripgrep-ma07p6tt.js";
+
+// src/database/drizzle/sqlite-core/effect/session.ts
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import { NoopCache, strategyFor } from "drizzle-orm/cache/core/cache";
+import { MigratorInitError } from "drizzle-orm/effect-core/errors";
+import { EffectDrizzleQueryError, EffectTransactionRollbackError } from "drizzle-orm/effect-core/errors";
+import { entityKind, is } from "drizzle-orm/entity";
+import { getMigrationsToRun } from "drizzle-orm/migrator.utils";
+import { makeJitRqbMapper } from "drizzle-orm/relations";
+import { fillPlaceholders, sql } from "drizzle-orm/sql/sql";
+import { assertUnreachable, makeJitQueryMapper } from "drizzle-orm/utils";
+class SQLiteEffectPreparedQuery {
+  executor;
+  query;
+  logger;
+  cache;
+  queryMetadata;
+  fields;
+  useJitMappers;
+  customResultMapper;
+  isRqbV2Query;
+  rqbConfig;
+  isInTransaction;
+  static [entityKind] = "SQLiteEffectPreparedQuery";
+  joinsNotNullableMap;
+  jitMapper;
+  cacheConfig;
+  effectExecuteMethod;
+  constructor(executor, query, logger, cache, queryMetadata, cacheConfig, fields, executeMethod, useJitMappers, customResultMapper, isRqbV2Query, rqbConfig, isInTransaction = Effect.succeed(false)) {
+    this.executor = executor;
+    this.query = query;
+    this.logger = logger;
+    this.cache = cache;
+    this.queryMetadata = queryMetadata;
+    this.fields = fields;
+    this.useJitMappers = useJitMappers;
+    this.customResultMapper = customResultMapper;
+    this.isRqbV2Query = isRqbV2Query;
+    this.rqbConfig = rqbConfig;
+    this.isInTransaction = isInTransaction;
+    this.effectExecuteMethod = executeMethod;
+    this.cacheConfig = cache.strategy() === "all" && cacheConfig === undefined ? { enabled: true, autoInvalidate: true } : cacheConfig;
+    if (!this.cacheConfig?.enabled) {
+      this.cacheConfig = undefined;
+    }
+  }
+  run(placeholderValues) {
+    return this.executeWithCache(placeholderValues, "run");
+  }
+  all(placeholderValues) {
+    if (this.isRqbV2Query)
+      return this.allRqbV2(placeholderValues);
+    if (!this.fields && !this.customResultMapper) {
+      return this.executeWithCache(placeholderValues, "all");
+    }
+    return this.executeWithCache(placeholderValues, "values", (rows) => this.mapAllResult(rows));
+  }
+  get(placeholderValues) {
+    if (this.isRqbV2Query)
+      return this.getRqbV2(placeholderValues);
+    if (!this.fields && !this.customResultMapper) {
+      return this.executeWithCache(placeholderValues, "get");
+    }
+    return this.executeWithCache(placeholderValues, "values", (rows) => this.mapGetResult(rows));
+  }
+  values(placeholderValues) {
+    return this.executeWithCache(placeholderValues, "values");
+  }
+  execute(placeholderValues) {
+    return this[this.effectExecuteMethod](placeholderValues);
+  }
+  mapRunResult(result, _isFromBatch) {
+    return result;
+  }
+  mapAllResult(rows, isFromBatch) {
+    if (isFromBatch) {
+      rows = Array.isArray(rows) ? rows : [];
+    }
+    if (!this.fields && !this.customResultMapper) {
+      return rows;
+    }
+    if (this.isRqbV2Query) {
+      return this.useJitMappers ? (this.jitMapper = this.jitMapper ?? makeJitRqbMapper(this.rqbConfig))(rows) : this.customResultMapper(rows);
+    }
+    if (this.customResultMapper) {
+      return this.customResultMapper(rows);
+    }
+    return this.useJitMappers ? (this.jitMapper = this.jitMapper ?? makeJitQueryMapper(this.fields, this.joinsNotNullableMap))(rows) : rows.map((row) => mapResultRow(this.fields, row, this.joinsNotNullableMap));
+  }
+  mapGetResult(rows, isFromBatch) {
+    if (isFromBatch) {
+      rows = Array.isArray(rows) ? rows : [];
+    }
+    if (!this.fields && !this.customResultMapper) {
+      return Array.isArray(rows) ? rows[0] : rows;
+    }
+    const row = Array.isArray(rows) ? rows[0] : rows;
+    if (!row)
+      return;
+    if (this.isRqbV2Query) {
+      return this.useJitMappers ? (this.jitMapper = this.jitMapper ?? makeJitRqbMapper(this.rqbConfig))([
+        row
+      ]) : this.customResultMapper([row]);
+    }
+    if (this.customResultMapper) {
+      return this.customResultMapper([row]);
+    }
+    return this.useJitMappers ? (this.jitMapper = this.jitMapper ?? makeJitQueryMapper(this.fields, this.joinsNotNullableMap))([row])[0] : mapResultRow(this.fields, row, this.joinsNotNullableMap);
+  }
+  allRqbV2(placeholderValues) {
+    return this.executeWithCache(placeholderValues, "all", (rows) => this.mapAllResult(rows));
+  }
+  getRqbV2(placeholderValues) {
+    return this.executeWithCache(placeholderValues, "get", (row) => row === undefined ? undefined : this.mapGetResult(row));
+  }
+  executeWithCache(placeholderValues, executeMethod, mapResult) {
+    return Effect.gen({ self: this }, function* () {
+      const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+      yield* this.logger.logQuery(this.query.sql, params);
+      return yield* this.queryWithCache(this.query.sql, params, Effect.suspend(() => this.executor(params, executeMethod)), mapResult);
+    });
+  }
+  mapCachedResult(result, mapResult) {
+    if (!mapResult)
+      return Effect.succeed(result);
+    return Effect.try({
+      try: () => mapResult(result),
+      catch: (cause) => cause
+    });
+  }
+  queryWithCache(queryString, params, query, mapResult) {
+    return Effect.gen({ self: this }, function* () {
+      if (this.queryMetadata?.type === "select" && this.cacheConfig?.enabled && (yield* this.isInTransaction)) {
+        return yield* this.mapCachedResult(yield* query, mapResult);
+      }
+      const cacheStrat = !is(this.cache.cache, NoopCache) ? yield* Effect.tryPromise(() => strategyFor(queryString, params, this.queryMetadata, this.cacheConfig)) : { type: "skip" };
+      if (cacheStrat.type === "skip") {
+        return yield* this.mapCachedResult(yield* query, mapResult);
+      }
+      if (cacheStrat.type === "invalidate") {
+        const result = yield* query;
+        yield* this.cache.onMutate({ tables: cacheStrat.tables });
+        return yield* this.mapCachedResult(result, mapResult);
+      }
+      if (cacheStrat.type === "try") {
+        if (yield* this.isInTransaction) {
+          return yield* this.mapCachedResult(yield* query, mapResult);
+        }
+        const { tables, key, isTag, autoInvalidate, config } = cacheStrat;
+        const fromCache = yield* this.cache.get(key, tables, isTag, autoInvalidate);
+        if (typeof fromCache !== "undefined") {
+          return yield* this.mapCachedResult(fromCache, mapResult);
+        }
+        const result = yield* query;
+        yield* this.cache.put(key, result, autoInvalidate ? tables : [], isTag, config);
+        return yield* this.mapCachedResult(result, mapResult);
+      }
+      assertUnreachable(cacheStrat);
+    }).pipe(Effect.catch((e) => {
+      return Effect.fail(new EffectDrizzleQueryError({ query: queryString, params, cause: Cause.fail(e) }));
+    }));
+  }
+  getQuery() {
+    return this.query;
+  }
+  mapResult(response, isFromBatch) {
+    switch (this.effectExecuteMethod) {
+      case "run": {
+        return this.mapRunResult(response, isFromBatch);
+      }
+      case "all": {
+        return this.mapAllResult(response, isFromBatch);
+      }
+      case "get": {
+        return this.mapGetResult(response, isFromBatch);
+      }
+    }
+  }
+}
+
+class SQLiteEffectSession {
+  dialect;
+  static [entityKind] = "SQLiteEffectSession";
+  constructor(dialect) {
+    this.dialect = dialect;
+  }
+  prepareOneTimeQuery(query, fields, executeMethod, customResultMapper, queryMetadata, cacheConfig) {
+    return this.prepareQuery(query, fields, executeMethod, customResultMapper, queryMetadata, cacheConfig);
+  }
+  prepareOneTimeRelationalQuery(query, fields, executeMethod, customResultMapper, config) {
+    return this.prepareRelationalQuery(query, fields, executeMethod, customResultMapper, config);
+  }
+  run(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), undefined, "run").run();
+  }
+  all(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), undefined, "all").all();
+  }
+  get(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), undefined, "get").get();
+  }
+  values(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), undefined, "all").values();
+  }
+  count(query) {
+    return this.values(query).pipe(Effect.map((result) => result[0]?.[0] ?? 0));
+  }
+}
+
+class SQLiteEffectTransaction extends SQLiteEffectDatabase {
+  relations;
+  static [entityKind] = "SQLiteEffectTransaction";
+  constructor(dialect, session, relations) {
+    super(dialect, session, relations);
+    this.relations = relations;
+  }
+  rollback() {
+    return new EffectTransactionRollbackError;
+  }
+}
+var migrate = Effect.fn("migrate")(function* (migrations, session, config) {
+  const migrationsTable = typeof config === "string" ? "__drizzle_migrations" : config.migrationsTable ?? "__drizzle_migrations";
+  const { newDb } = yield* upgradeIfNeeded(migrationsTable, session, migrations);
+  if (newDb) {
+    yield* session.run(sql`
+		CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+			id INTEGER PRIMARY KEY,
+			hash text NOT NULL,
+			created_at numeric,
+			name text,
+			applied_at TEXT
+		)
+	`);
+  }
+  const dbMigrations = yield* session.all(sql`SELECT id, hash, created_at, name FROM ${sql.identifier(migrationsTable)}`);
+  if (typeof config === "object" && config.init) {
+    if (dbMigrations.length) {
+      return yield* new MigratorInitError({ exitCode: "databaseMigrations" });
+    }
+    if (migrations.length > 1) {
+      return yield* new MigratorInitError({ exitCode: "localMigrations" });
+    }
+    const [migration] = migrations;
+    if (!migration)
+      return;
+    yield* session.run(sql`insert into ${sql.identifier(migrationsTable)} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${new Date().toISOString()})`);
+    return;
+  }
+  const migrationsToRun = getMigrationsToRun({ localMigrations: migrations, dbMigrations });
+  if (migrationsToRun.length === 0)
+    return;
+  yield* session.transaction((tx) => Effect.gen(function* () {
+    for (const migration of migrationsToRun) {
+      for (const stmt of migration.sql) {
+        yield* tx.run(sql.raw(stmt));
+      }
+      yield* tx.run(sql`insert into ${sql.identifier(migrationsTable)} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${new Date().toISOString()})`);
+    }
+  }));
+});
+
+export { SQLiteEffectPreparedQuery, SQLiteEffectSession, SQLiteEffectTransaction, migrate };

package/dist/chunks/ripgrep-fje0n842.js

@@ -0,0 +1,112 @@
+import {
+  exports_instruction_discovery
+} from "./ripgrep-8rhqsgy6.js";
+import {
+  exports_watcher
+} from "./ripgrep-y980s7ka.js";
+import {
+  exports_instructions
+} from "./ripgrep-8k8ks5a6.js";
+import {
+  exports_location
+} from "./ripgrep-hcyadm03.js";
+import {
+  AbsolutePath
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/config/plugin/instruction.ts
+var exports_instruction = {};
+__export(exports_instruction, {
+  Plugin: () => Plugin,
+  ConfigInstructionPlugin: () => exports_instruction
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Global } from "@opencode-ai/util/global";
+import { dirname, join } from "path";
+import { Effect, PubSub, Semaphore, Stream } from "effect";
+var Plugin = define({
+  id: "opencode.config.instruction",
+  effect: Effect.fn(function* () {
+    const discovery = yield* exports_instruction_discovery.Service;
+    yield* Effect.gen(function* () {
+      const fs = yield* FSUtil.Service;
+      const global = yield* Global.Service;
+      const location = yield* exports_location.Service;
+      const watcher = yield* exports_watcher.Service;
+      const changes = yield* PubSub.sliding(1);
+      const lock = Semaphore.makeUnsafe(1);
+      const start = yield* fs.resolve(location.directory);
+      const root = yield* fs.resolve(location.project.directory);
+      const home = yield* fs.resolve(global.home);
+      const project = discovery.project && FSUtil.contains(root, start);
+      const stop = FSUtil.contains(home, start) ? home : root;
+      const globalFile = yield* fs.resolve(join(global.config, "AGENTS.md"));
+      const loaded = { current: { type: "available", files: [] } };
+      const publish = (update) => PubSub.publish(changes, update.path).pipe(Effect.asVoid);
+      const candidates = [
+        globalFile,
+        ...project ? ancestorDirectories(start, stop).map((directory) => join(directory, "AGENTS.md")) : []
+      ];
+      for (const path of new Set(candidates)) {
+        const updates = yield* watcher.subscribe({ path, type: "file" });
+        yield* updates.pipe(Stream.runForEach(publish), Effect.forkScoped({ startImmediately: true }));
+      }
+      const read = Effect.fn("ConfigInstructionPlugin.read")(function* (path) {
+        const content = yield* fs.readFileStringSafe(path);
+        if (content !== undefined)
+          return new exports_instruction_discovery.File({ path: AbsolutePath.make(path), content });
+        yield* Effect.logDebug("instruction file skipped", { path, reason: "unavailable" });
+      });
+      const globalSource = Effect.fn("ConfigInstructionPlugin.globalSource")(function* () {
+        const file = yield* read(globalFile);
+        return file ? [file] : [];
+      });
+      const projectSource = Effect.fn("ConfigInstructionPlugin.projectSource")(function* () {
+        if (!project)
+          return [];
+        const discovered = new Set(yield* Effect.forEach(yield* fs.up({ targets: ["AGENTS.md"], start, stop }), fs.resolve));
+        const files = yield* Effect.forEach(discovered, read, { concurrency: "unbounded" });
+        if (files.some((file) => file === undefined))
+          return exports_instructions.unavailable;
+        return files.filter((file) => file !== undefined);
+      });
+      const isolate = (source, effect) => effect.pipe(Effect.catchCause((cause) => Effect.logWarning("failed to load instruction source", { source, cause }).pipe(Effect.as(exports_instructions.unavailable))));
+      const refresh = Effect.fn("ConfigInstructionPlugin.refresh")(function* (file) {
+        yield* lock.withPermit(Effect.gen(function* () {
+          const sources = yield* Effect.all({
+            global: isolate("global", globalSource()),
+            project: isolate("project", projectSource())
+          });
+          loaded.current = Array.isArray(sources.global) && Array.isArray(sources.project) ? { type: "available", files: [...sources.global, ...sources.project] } : { type: "unavailable" };
+          if (!file)
+            return;
+          yield* Effect.logDebug("instructions rescanned", {
+            file,
+            instructions: loaded.current.type === "available" ? loaded.current.files.map((item) => item.path) : "unavailable"
+          });
+        }));
+      });
+      yield* Stream.fromPubSub(changes).pipe(Stream.runForEach((file) => refresh(file).pipe(Effect.andThen(discovery.reload()))), Effect.forkScoped({ startImmediately: true }));
+      yield* refresh();
+      yield* discovery.transform((draft) => {
+        if (loaded.current.type === "unavailable") {
+          draft.unavailable();
+          return;
+        }
+        for (const file of loaded.current.files)
+          draft.add(file);
+      });
+    }).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to activate instruction source", { cause }).pipe(Effect.andThen(discovery.transform((draft) => draft.unavailable())), Effect.asVoid)));
+  })
+});
+function ancestorDirectories(start, stop) {
+  if (start === stop)
+    return [start];
+  return [start, ...ancestorDirectories(dirname(start), stop)];
+}
+
+export { Plugin, exports_instruction };

package/dist/chunks/ripgrep-fm1nvm5g.js

@@ -0,0 +1,32 @@
+import {
+  exports_provider
+} from "./ripgrep-d6vvk673.js";
+
+// src/plugin/provider/nvidia.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var NvidiaPlugin = define({
+  id: "opencode.provider.nvidia",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!exports_provider.isAISDK(item.provider.package))
+          continue;
+        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/openai-compatible")
+          continue;
+        if (item.provider.settings?.baseURL !== "https://integrate.api.nvidia.com/v1")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = {
+            ...provider.headers,
+            "HTTP-Referer": "https://opencode.ai/",
+            "X-Title": "opencode",
+            "X-BILLING-INVOKE-ORIGIN": provider.headers?.["X-BILLING-INVOKE-ORIGIN"] ?? "OpenCode"
+          };
+        });
+      }
+    });
+  })
+});
+
+export { NvidiaPlugin };

package/dist/chunks/ripgrep-fmyre8m1.js

@@ -0,0 +1,24 @@
+import {
+  __require
+} from "./ripgrep-rvfvac9x.js";
+
+// src/plugin/provider/openai-compatible.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var OpenAICompatiblePlugin = define({
+  id: "opencode.provider.openai-compatible",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.sdk)
+        return;
+      if (!evt.package.includes("@ai-sdk/openai-compatible"))
+        return;
+      if (evt.options.includeUsage !== false)
+        evt.options.includeUsage = true;
+      const mod = yield* Effect.promise(() => import("@ai-sdk/openai-compatible"));
+      evt.sdk = mod.createOpenAICompatible(evt.options);
+    }));
+  })
+});
+
+export { OpenAICompatiblePlugin };

package/dist/chunks/ripgrep-g7k9te92.js

@@ -0,0 +1,15 @@
+// src/util/which.ts
+import whichPkg from "which";
+import path from "path";
+function which(cmd, env, bin) {
+  const base = env?.PATH ?? env?.Path ?? process.env.PATH ?? process.env.Path ?? "";
+  const full = base && bin ? base + path.delimiter + bin : base || 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;
+}
+
+export { which };

package/dist/chunks/ripgrep-g9yygpzr.js

@@ -0,0 +1,80 @@
+import {
+  getTableColumnsRuntime,
+  orderSelectedFields
+} from "./ripgrep-ma07p6tt.js";
+
+// src/database/drizzle/sqlite-core/effect/delete.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import { SelectionProxyHandler } from "drizzle-orm/selection-proxy";
+import { extractUsedTable } from "drizzle-orm/sqlite-core/utils";
+class SQLiteEffectDeleteBase {
+  table;
+  effectSession;
+  effectDialect;
+  static [entityKind] = "SQLiteEffectDelete";
+  config;
+  constructor(table, effectSession, effectDialect, withList) {
+    this.table = table;
+    this.effectSession = effectSession;
+    this.effectDialect = effectDialect;
+    this.config = { table, withList };
+  }
+  where(where) {
+    this.config.where = where;
+    return this;
+  }
+  orderBy(...columns) {
+    if (typeof columns[0] === "function") {
+      const orderBy = columns[0](new Proxy(getTableColumnsRuntime(this.config.table), new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })));
+      this.config.orderBy = Array.isArray(orderBy) ? orderBy : [orderBy];
+      return this;
+    }
+    this.config.orderBy = columns;
+    return this;
+  }
+  limit(limit) {
+    this.config.limit = limit;
+    return this;
+  }
+  returning(fields = getTableColumnsRuntime(this.table)) {
+    this.config.returning = orderSelectedFields(fields);
+    return this;
+  }
+  getSQL() {
+    return this.effectDialect.buildDeleteQuery(this.config);
+  }
+  toSQL() {
+    return this.effectDialect.sqlToQuery(this.getSQL());
+  }
+  _prepare(isOneTimeQuery = true) {
+    return this.effectSession[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.effectDialect.sqlToQuery(this.getSQL()), this.config.returning, this.config.returning ? "all" : "run", undefined, {
+      type: "delete",
+      tables: extractUsedTable(this.config.table)
+    });
+  }
+  prepare() {
+    return this._prepare(false);
+  }
+  run = (placeholderValues) => {
+    return this._prepare().run(placeholderValues);
+  };
+  all = (placeholderValues) => {
+    return this._prepare().all(placeholderValues);
+  };
+  get = (placeholderValues) => {
+    return this._prepare().get(placeholderValues);
+  };
+  values = (placeholderValues) => {
+    return this._prepare().values(placeholderValues);
+  };
+  execute = (placeholderValues) => {
+    return this._prepare().execute(placeholderValues);
+  };
+  $dynamic() {
+    return this;
+  }
+}
+applyEffectWrapper(SQLiteEffectDeleteBase);
+
+export { SQLiteEffectDeleteBase };

package/dist/chunks/ripgrep-gcay93cp.js

@@ -0,0 +1,14 @@
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/v1/config/layout.ts
+var exports_layout = {};
+__export(exports_layout, {
+  Layout: () => Layout,
+  ConfigLayoutV1: () => exports_layout
+});
+import { Schema } from "effect";
+var Layout = Schema.Literals(["auto", "stretch"]).annotate({ identifier: "LayoutConfig" });
+
+export { Layout, exports_layout };

package/dist/chunks/ripgrep-gd2xppx8.js

@@ -0,0 +1,14 @@
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/file.ts
+var exports_file = {};
+__export(exports_file, {
+  File: () => exports_file,
+  Diff: () => Diff
+});
+import { FileDiff } from "@opencode-ai/schema/file-diff";
+var Diff = FileDiff.Info;
+
+export { Diff, exports_file };

package/dist/chunks/ripgrep-gd5xeqc2.js

@@ -0,0 +1,32 @@
+// src/database/migration/20260228203230_blue_harpoon.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260228203230_blue_harpoon",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`account\` (
+          \`id\` text PRIMARY KEY,
+          \`email\` text NOT NULL,
+          \`url\` text NOT NULL,
+          \`access_token\` text NOT NULL,
+          \`refresh_token\` text NOT NULL,
+          \`token_expiry\` integer,
+          \`selected_org_id\` text,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`account_state\` (
+          \`id\` integer PRIMARY KEY NOT NULL,
+          \`active_account_id\` text,
+          FOREIGN KEY (\`active_account_id\`) REFERENCES \`account\`(\`id\`) ON UPDATE no action ON DELETE set null
+        );
+      `);
+    });
+  }
+};
+var _20260228203230_blue_harpoon_default = migration;
+
+export { _20260228203230_blue_harpoon_default };