@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-vy36sswr.js

@@ -0,0 +1,40 @@
+import {
+  Service42
+} from "./aisdk-native-81rrwt6s.js";
+import {
+  awaitActivation2
+} from "./aisdk-native-1x11rq2a.js";
+import {
+  Service32
+} from "./aisdk-native-c8k0fn6w.js";
+import {
+  unavailable2
+} from "./aisdk-native-fxbjtjnd.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/session/shell.ts
+var exports_shell3 = {};
+__export(exports_shell3, {
+  SessionShell: () => exports_shell3,
+  start: () => start2
+});
+import { Effect } from "effect";
+var start2 = Effect.fn("SessionShell.start")(function* (input) {
+  const instances = yield* Service42;
+  const shell = yield* awaitActivation2.pipe(Effect.andThen(Service32), instances.provide(input.session));
+  const info = yield* shell.create({
+    command: input.command,
+    cwd: input.session.location.directory,
+    timeout: 0,
+    metadata: { sessionID: input.session.id, background: true }
+  });
+  return {
+    info,
+    result: shell.result(info),
+    output: shell.output(info.id, { limit: 1024 * 1024 }).pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.succeed(unavailable2)))
+  };
+});
+
+export { start2, exports_shell3 };

package/dist/chunks/aisdk-native-vzcthcp8.js

@@ -0,0 +1,21 @@
+import {
+  loadSDKFactory2
+} from "./aisdk-native-hjbc5kem.js";
+
+// src/plugin/provider/dynamic.ts
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+import { Npm } from "@opencode/util/npm";
+var DynamicProviderPlugin2 = define({
+  id: "opencode.provider.dynamic",
+  effect: Effect.fn(function* (ctx) {
+    const npm = yield* Npm.Service;
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.sdk)
+        return;
+      evt.sdk = (yield* loadSDKFactory2(npm, evt.package))(evt.options);
+    }));
+  })
+});
+
+export { DynamicProviderPlugin2 };

package/dist/chunks/aisdk-native-w3wsvvr9.js

@@ -0,0 +1,80 @@
+import {
+  getTableColumnsRuntime2,
+  orderSelectedFields2
+} from "./aisdk-native-emrn6kk6.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 SQLiteEffectDeleteBase2 {
+  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(getTableColumnsRuntime2(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 = getTableColumnsRuntime2(this.table)) {
+    this.config.returning = orderSelectedFields2(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(SQLiteEffectDeleteBase2);
+
+export { SQLiteEffectDeleteBase2 };

package/dist/chunks/aisdk-native-w4arg62q.js

@@ -0,0 +1,84 @@
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/v1/config/lsp.ts
+var exports_lsp = {};
+__export(exports_lsp, {
+  ConfigLSPV1: () => exports_lsp,
+  Disabled: () => Disabled2,
+  Entry: () => Entry3,
+  Info: () => Info9,
+  builtinServerIds: () => builtinServerIds2,
+  requiresExtensionsForCustomServers: () => requiresExtensionsForCustomServers2
+});
+import { Schema } from "effect";
+var Disabled2 = Schema.Struct({
+  disabled: Schema.Literal(true)
+});
+var Entry3 = Schema.Union([
+  Disabled2,
+  Schema.Struct({
+    command: Schema.mutable(Schema.Array(Schema.String)),
+    extensions: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
+    disabled: Schema.optional(Schema.Boolean),
+    env: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    initialization: Schema.optional(Schema.Record(Schema.String, Schema.Unknown))
+  })
+]);
+var builtinServerIds2 = [
+  "deno",
+  "typescript",
+  "vue",
+  "eslint",
+  "oxlint",
+  "biome",
+  "gopls",
+  "ruby-lsp",
+  "ty",
+  "pyright",
+  "elixir-ls",
+  "zls",
+  "csharp",
+  "razor",
+  "fsharp",
+  "sourcekit-lsp",
+  "rust",
+  "clangd",
+  "svelte",
+  "astro",
+  "jdtls",
+  "kotlin-ls",
+  "yaml-ls",
+  "lua-ls",
+  "php intelephense",
+  "prisma",
+  "dart",
+  "ocaml-lsp",
+  "bash",
+  "terraform",
+  "texlab",
+  "dockerfile",
+  "gleam",
+  "clojure-lsp",
+  "nixd",
+  "tinymist",
+  "haskell-language-server",
+  "julials"
+];
+var requiresExtensionsForCustomServers2 = Schema.makeFilter((data) => {
+  if (typeof data === "boolean")
+    return;
+  const ids = new Set(builtinServerIds2);
+  const ok = Object.entries(data).every(([id, config]) => {
+    if ("disabled" in config && config.disabled)
+      return true;
+    if (ids.has(id))
+      return true;
+    return "extensions" in config && Boolean(config.extensions);
+  });
+  return ok ? undefined : "For custom LSP servers, 'extensions' array is required.";
+});
+var Info9 = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry3)]).check(requiresExtensionsForCustomServers2);
+
+export { Disabled2, Entry3, builtinServerIds2, requiresExtensionsForCustomServers2, Info9, exports_lsp };

package/dist/chunks/aisdk-native-w69f1nhp.js

@@ -0,0 +1,140 @@
+import {
+  Service36,
+  node40
+} from "./aisdk-native-39dcxt5x.js";
+import {
+  Service73,
+  node78
+} from "./aisdk-native-6fyvx278.js";
+import {
+  Service35,
+  node39
+} from "./aisdk-native-y9tfvs3x.js";
+import {
+  names2,
+  discover2
+} from "./aisdk-native-zxq2ej10.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/config/plugin/source.ts
+var exports_source = {};
+__export(exports_source, {
+  ConfigPluginSource: () => exports_source,
+  Service: () => Service3,
+  empty: () => empty2,
+  layer: () => layer5,
+  node: () => node6
+});
+import { FSUtil } from "@opencode/util/fs-util";
+import { Host } from "@opencode/plugin/host";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer, Option, PubSub, Stream } from "effect";
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+class Service3 extends Context.Service()("@opencode/ConfigPluginSource") {
+}
+var layer5 = Layer.effect(Service3, Effect.gen(function* () {
+  const config = yield* Service35;
+  const watcher = yield* Service36;
+  const fs = yield* FSUtil.Service;
+  const location = yield* Service73;
+  const configuredChanges = yield* PubSub.unbounded();
+  const watched = new Set;
+  const watchConfiguredSources = Effect.fn("ConfigPluginSource.watchConfiguredSources")(function* (entries, operations) {
+    for (const operation of operations) {
+      if (operation.type !== "add" || !path.isAbsolute(operation.target))
+        continue;
+      if (watched.has(operation.target))
+        continue;
+      if (isPluginSource(entries, operation.target))
+        continue;
+      watched.add(operation.target);
+      const updates = yield* watcher.subscribe({
+        path: operation.target,
+        type: (yield* fs.isDir(operation.target)) ? "directory" : "file"
+      });
+      yield* updates.pipe(Stream.runForEach(() => PubSub.publish(configuredChanges, undefined)), Effect.catchCause((cause) => Effect.logError("configured plugin watch failed", { target: operation.target, cause })), Effect.forkScoped({ startImmediately: true }));
+    }
+  });
+  return Service3.of({
+    operations: Effect.fn("ConfigPluginSource.operations")(function* () {
+      const entries = yield* config.entries();
+      const operations = yield* scan(fs, location, entries);
+      yield* watchConfiguredSources(entries, operations);
+      return operations;
+    }),
+    changes: () => Stream.merge(config.changes().pipe(Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isPluginSource(entries, update.path))), Stream.map(() => {
+      return;
+    })), Stream.fromPubSub(configuredChanges))
+  });
+}));
+var node6 = makeLocationNode({
+  service: Service3,
+  layer: layer5,
+  deps: [node39, FSUtil.node, node40, node78]
+});
+var empty2 = makeLocationNode({
+  service: Service3,
+  layer: Layer.succeed(Service3, Service3.of({
+    operations: () => Effect.succeed([]),
+    changes: () => Stream.never
+  })),
+  deps: []
+});
+function parse(input) {
+  if (typeof input !== "string") {
+    return { type: "add", target: input.package, options: input.options ?? {} };
+  }
+  if (!input.startsWith("-"))
+    return { type: "add", target: input, options: {} };
+  if (input.length === 1)
+    throw new Error("Plugin remove operation requires a target");
+  return { type: "remove", target: input.slice(1) };
+}
+var scan = Effect.fn("ConfigPluginSource.scan")(function* (fs, location, entries) {
+  const discovered = yield* Effect.forEach(entries.filter((entry) => entry.type === "directory"), (entry) => discover2(fs, entry.path).pipe(Effect.map((targets) => targets.map((target) => ({ type: "add", target, options: {} }))))).pipe(Effect.map((items) => items.flat()));
+  const configured = entries.filter((entry) => entry.type === "document").flatMap((entry) => (entry.info.plugins ?? []).map(parse).map((operation) => {
+    if (operation.type === "remove")
+      return operation;
+    const directory = entry.path ? path.dirname(entry.path) : location.directory;
+    const target = operation.target.startsWith("file://") ? fileURLToPath(operation.target) : operation.target.startsWith("./") || operation.target.startsWith("../") ? path.resolve(directory, operation.target) : operation.target;
+    return { ...operation, target };
+  }));
+  const resolved = yield* Effect.forEach(configured, (operation) => Effect.gen(function* () {
+    if (operation.type === "remove" || !path.isAbsolute(operation.target))
+      return Option.some(operation);
+    if (yield* fs.isFile(operation.target)) {
+      yield* Effect.logWarning("configured plugin path must be a directory", { target: operation.target });
+      return Option.none();
+    }
+    return Option.some(operation);
+  })).pipe(Effect.map((operations) => operations.flatMap(Option.toArray)));
+  return yield* Effect.forEach([...discovered, ...resolved], (operation) => Effect.gen(function* () {
+    if (operation.type === "remove" || !path.isAbsolute(operation.target))
+      return [operation];
+    if (!(yield* fs.existsSafe(operation.target)))
+      return [operation];
+    const directory = yield* fs.isDir(operation.target);
+    const entrypoints = directory ? yield* Effect.sync(() => Host.resolve({ directory: operation.target })) : { server: pathToFileURL(operation.target).href };
+    if (!entrypoints.server)
+      return [];
+    if (directory) {
+      const root = yield* fs.resolve(operation.target);
+      const server = yield* fs.resolve(fileURLToPath(entrypoints.server));
+      if (!FSUtil.contains(root, server))
+        return [];
+    }
+    const times = yield* Effect.forEach([
+      ...Object.values(entrypoints).filter((entry) => entry !== undefined).map((entry) => fileURLToPath(entry)),
+      path.join(directory ? operation.target : path.dirname(operation.target), "package.json")
+    ], (entry) => fs.stat(entry).pipe(Effect.map((info) => Option.getOrElse(info.mtime, () => new Date(0)).getTime()), Effect.orElseSucceed(() => 0)));
+    return [{ ...operation, mtime: Math.max(...times) }];
+  })).pipe(Effect.map((operations) => operations.flat()));
+});
+function isPluginSource(entries, file) {
+  return entries.some((entry) => entry.type === "directory" && names2.some((directory) => FSUtil.contains(path.join(entry.path, directory), file)));
+}
+
+export { Service3, layer5, node6, empty2, exports_source };

package/dist/chunks/aisdk-native-w803qqfp.js

@@ -0,0 +1,16 @@
+// src/database/migration/20260603160727_jittery_ezekiel_stane.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260603160727_jittery_ezekiel_stane",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_input_session_pending_seq_idx\`;`);
+      yield* tx.run(`CREATE INDEX IF NOT EXISTS \`event_aggregate_type_seq_idx\` ON \`event\` (\`aggregate_id\`,\`type\`,\`seq\`);`);
+      yield* tx.run(`CREATE INDEX IF NOT EXISTS \`session_input_session_pending_delivery_seq_idx\` ON \`session_input\` (\`session_id\`,\`promoted_seq\`,\`delivery\`,\`seq\`);`);
+      yield* tx.run(`CREATE INDEX IF NOT EXISTS \`session_message_session_time_created_id_idx\` ON \`session_message\` (\`session_id\`,\`time_created\`,\`id\`);`);
+    });
+  }
+};
+var _20260603160727_jittery_ezekiel_stane_default = migration;
+
+export { _20260603160727_jittery_ezekiel_stane_default };

package/dist/chunks/aisdk-native-wavq5vqb.js

@@ -0,0 +1,24 @@
+import {
+  packageName2
+} from "./aisdk-native-33n3bzdy.js";
+
+// src/plugin/provider/cerebras.ts
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+var CerebrasPlugin2 = define({
+  id: "opencode.provider.cerebras",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        const name = packageName2(item.provider.package);
+        if (name !== "@ai-sdk/cerebras" && name !== "@opencode/ai/providers/cerebras")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = { ...provider.headers, "X-Cerebras-3rd-Party-Integration": "opencode" };
+        });
+      }
+    });
+  })
+});
+
+export { CerebrasPlugin2 };

package/dist/chunks/aisdk-native-wb8tnnnp.js

@@ -0,0 +1,99 @@
+import {
+  Service79
+} from "./aisdk-native-11nvngjf.js";
+import {
+  Service52,
+  Event10
+} from "./aisdk-native-sxnsykqc.js";
+
+// src/plugin/models-dev.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Integration } from "@opencode/schema/integration";
+import { Provider } from "@opencode/schema/provider";
+import { Effect, Stream } from "effect";
+var BEDROCK_PROFILE_ONLY_IDS = [
+  "amazon.nova-2-lite-v1:0",
+  "anthropic.claude-fable-5",
+  "anthropic.claude-fable-5-1",
+  "anthropic.claude-haiku-4-5-20251001-v1:0",
+  "anthropic.claude-opus-4-1-20250805-v1:0",
+  "anthropic.claude-opus-4-5-20251101-v1:0",
+  "anthropic.claude-opus-4-7",
+  "anthropic.claude-opus-4-8",
+  "anthropic.claude-opus-5",
+  "anthropic.claude-sonnet-4-5-20250929-v1:0",
+  "anthropic.claude-sonnet-5",
+  "deepseek.r1-v1:0",
+  "mistral.pixtral-large-2502-v1:0"
+];
+var ModelsDevPlugin2 = define({
+  id: "opencode.models.dev",
+  effect: Effect.fn(function* (ctx) {
+    const modelsDev = yield* Service52;
+    const bus = yield* Service79;
+    const loaded = { data: snapshots(yield* modelsDev.get()) };
+    yield* ctx.integration.transform((integrations) => {
+      for (const provider of loaded.data) {
+        if (provider.environment.length === 0)
+          continue;
+        const integrationID = provider.info.id;
+        integrations.update(integrationID, (integration) => integration.name = provider.info.name);
+        integrations.method.update({
+          integrationID,
+          method: { type: "key" }
+        });
+        integrations.method.update({
+          integrationID,
+          method: {
+            type: "env",
+            names: environmentNames(provider)
+          }
+        });
+      }
+    });
+    yield* ctx.catalog.transform((catalog) => {
+      for (const provider of loaded.data) {
+        catalog.provider.update(provider.info.id, (draft) => {
+          Object.assign(draft, copy(provider.info));
+          draft.integrationID = Integration.ID.make(provider.info.id);
+        });
+        for (const model of provider.models) {
+          if (model.status === "deprecated")
+            continue;
+          if (provider.info.id === Provider.ID.amazonBedrock && BEDROCK_PROFILE_ONLY_IDS.includes(model.modelID ?? model.id))
+            continue;
+          catalog.model.update(provider.info.id, model.id, (draft) => Object.assign(draft, copy(model)));
+        }
+      }
+    });
+    yield* bus.subscribe(Event10.Refreshed).pipe(Stream.runForEach(() => modelsDev.get().pipe(Effect.tap((data) => Effect.sync(() => loaded.data = snapshots(data))), Effect.andThen(ctx.integration.reload()), Effect.andThen(ctx.catalog.reload()))), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+function environmentNames(provider) {
+  if (provider.info.id === Provider.ID.azure)
+    return [...provider.environment.filter((name) => name.endsWith("_API_KEY")), "AZURE_COGNITIVE_SERVICES_API_KEY"];
+  if (provider.info.id === Provider.ID.googleVertex)
+    return ["GOOGLE_VERTEX_API_KEY"];
+  return [...provider.environment];
+}
+function snapshots(data) {
+  return data.filter((provider) => provider.info.id !== "azure-cognitive-services" && provider.info.id !== "google-vertex-anthropic");
+}
+function copy(value) {
+  if (Array.isArray(value))
+    return value.map(copy);
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const key of Object.keys(value)) {
+      const copied = copy(value[key]);
+      if (key === "__proto__")
+        Object.defineProperty(result, key, { value: copied, enumerable: true, writable: true, configurable: true });
+      else
+        result[key] = copied;
+    }
+    return result;
+  }
+  return value;
+}
+
+export { ModelsDevPlugin2 };

package/dist/chunks/aisdk-native-wbvqwd2e.js

@@ -0,0 +1,44 @@
+import {
+  Service73,
+  node78
+} from "./aisdk-native-6fyvx278.js";
+import {
+  Service27
+} from "./aisdk-native-1x11rq2a.js";
+import {
+  Service49,
+  node52
+} from "./aisdk-native-9z45pttg.js";
+import {
+  node22
+} from "./aisdk-native-33f8ypwy.js";
+import {
+  node5
+} from "./aisdk-native-4kkrbspp.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/worktree/refresh.ts
+var exports_refresh = {};
+__export(exports_refresh, {
+  WorktreeRefresh: () => exports_refresh,
+  node: () => node4
+});
+import { Effect, Layer } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+var layer = Layer.effectDiscard(Effect.gen(function* () {
+  const location = yield* Service73;
+  const plugins = yield* Service27;
+  const worktrees = yield* Service49;
+  if (location.workspaceID)
+    return;
+  yield* plugins.awaitActivation.pipe(Effect.andThen(worktrees.refresh()), Effect.catchCause((cause) => Effect.logWarning("worktree refresh failed", { cause })), Effect.forkScoped);
+}));
+var node4 = makeLocationNode({
+  name: "worktree-refresh",
+  layer,
+  deps: [node52, node78, node22, node5]
+});
+
+export { node4, exports_refresh };

package/dist/chunks/aisdk-native-wd87259q.js

@@ -0,0 +1,102 @@
+import {
+  getViewSelectedFieldsRuntime2,
+  orderSelectedFields2
+} from "./aisdk-native-emrn6kk6.js";
+
+// src/database/drizzle/sqlite-core/effect/select.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind, is } from "drizzle-orm/entity";
+import { SQL } from "drizzle-orm/sql/sql";
+import { SQLiteSelectBase } from "drizzle-orm/sqlite-core/query-builders/select";
+import { SQLiteViewBase } from "drizzle-orm/sqlite-core/view-base";
+import { Subquery } from "drizzle-orm/subquery";
+import { getTableColumns } from "drizzle-orm/utils";
+class SQLiteEffectSelectBuilder2 {
+  static [entityKind] = "SQLiteEffectSelectBuilder";
+  fields;
+  session;
+  dialect;
+  withList;
+  distinct;
+  constructor(config) {
+    this.fields = config.fields;
+    this.session = config.session;
+    this.dialect = config.dialect;
+    this.withList = config.withList;
+    this.distinct = config.distinct;
+  }
+  from(source) {
+    const isPartialSelect = !!this.fields;
+    let fields;
+    if (this.fields) {
+      fields = this.fields;
+    } else if (is(source, Subquery)) {
+      fields = Object.fromEntries(Object.keys(source._.selectedFields).map((key) => [
+        key,
+        source[key]
+      ]));
+    } else if (is(source, SQLiteViewBase)) {
+      fields = getViewSelectedFieldsRuntime2(source).selectedFields;
+    } else if (is(source, SQL)) {
+      fields = {};
+    } else {
+      fields = getTableColumns(source);
+    }
+    return new SQLiteEffectSelectBase2({
+      table: source,
+      fields,
+      isPartialSelect,
+      session: this.session,
+      dialect: this.dialect,
+      withList: this.withList,
+      distinct: this.distinct
+    });
+  }
+}
+
+class SQLiteEffectSelectBase2 extends SQLiteSelectBase {
+  static [entityKind] = "SQLiteEffectSelect";
+  get effectConfig() {
+    return this.config;
+  }
+  getSQL() {
+    return this.dialect.buildSelectQuery(this.effectConfig);
+  }
+  _prepare(isOneTimeQuery = true) {
+    if (!this.session) {
+      throw new Error("Cannot execute a query on a query builder. Please use a database instance instead.");
+    }
+    const session = this.session;
+    const query = session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.dialect.sqlToQuery(this.getSQL()), orderSelectedFields2(this.effectConfig.fields), "all", undefined, {
+      type: "select",
+      tables: [...this.usedTables]
+    }, this.cacheConfig);
+    query.joinsNotNullableMap = this.joinsNotNullableMap;
+    return query;
+  }
+  $withCache(config) {
+    this.cacheConfig = config === undefined ? { config: {}, enabled: true, autoInvalidate: true } : config === false ? { enabled: false } : { enabled: true, autoInvalidate: true, ...config };
+    return this;
+  }
+  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);
+  };
+}
+applyEffectWrapper(SQLiteEffectSelectBase2);
+
+export { SQLiteEffectSelectBuilder2, SQLiteEffectSelectBase2 };

package/dist/chunks/aisdk-native-wer8tq1h.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260601202201_amazing_prowler.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260601202201_amazing_prowler",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP TABLE \`permission\`;`);
+    });
+  }
+};
+var _20260601202201_amazing_prowler_default = migration;
+
+export { _20260601202201_amazing_prowler_default };