@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-fcma1w1x.js

@@ -0,0 +1,75 @@
+import {
+  exports_reference
+} from "./location-mutation-rzy4xjjz.js";
+import {
+  exports_config
+} from "./location-mutation-qvf5nvg0.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  AbsolutePath
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/config/plugin/reference.ts
+var exports_reference2 = {};
+__export(exports_reference2, {
+  Plugin: () => Plugin,
+  ConfigReferencePlugin: () => exports_reference2
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import path from "path";
+import { Effect, Stream } from "effect";
+import { Global } from "@opencode-ai/util/global";
+var Plugin = define({
+  id: "opencode.config.reference",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* exports_config.Service;
+    const location = yield* exports_location.Service;
+    const global = yield* Global.Service;
+    const loaded = { entries: yield* config.entries() };
+    yield* ctx.reference.transform((draft) => {
+      const entries = new Map;
+      for (const doc of loaded.entries.filter((entry) => entry.type === "document")) {
+        const directory = doc.path ? path.dirname(doc.path) : location.directory;
+        for (const [name, entry] of Object.entries(doc.info.references ?? {})) {
+          if (!validAlias(name))
+            continue;
+          const description = typeof entry === "string" ? undefined : entry.description;
+          const hidden = typeof entry === "string" ? undefined : entry.hidden;
+          entries.set(name, local(entry) ? exports_reference.LocalSource.make({
+            type: "local",
+            path: AbsolutePath.make(localPath(directory, global.home, typeof entry === "string" ? entry : entry.path)),
+            ...description === undefined ? {} : { description },
+            ...hidden === undefined ? {} : { hidden }
+          }) : exports_reference.GitSource.make({
+            type: "git",
+            repository: typeof entry === "string" ? entry : entry.repository,
+            ...entry.branch === undefined ? {} : { branch: entry.branch },
+            ...description === undefined ? {} : { description },
+            ...hidden === undefined ? {} : { hidden }
+          }));
+        }
+      }
+      for (const [name, source] of entries)
+        draft.add(name, source);
+    });
+    yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(() => config.entries().pipe(Effect.tap((entries) => Effect.sync(() => loaded.entries = entries)), Effect.andThen(ctx.reference.reload()))), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+function validAlias(name) {
+  return name.length > 0 && !/[\/\s`,]/.test(name);
+}
+function local(entry) {
+  return typeof entry === "string" ? entry.startsWith(".") || entry.startsWith("/") || entry.startsWith("~") : ("path" in entry);
+}
+function localPath(directory, home, value) {
+  if (value.startsWith("~/"))
+    return path.join(home, value.slice(2));
+  return path.isAbsolute(value) ? value : path.resolve(directory, value);
+}
+
+export { Plugin, exports_reference2 as exports_reference };

package/dist/chunks/location-mutation-ffvt207n.js

@@ -0,0 +1,68 @@
+import {
+  exports_config
+} from "./location-mutation-qvf5nvg0.js";
+import {
+  __export,
+  __require
+} from "./location-mutation-rvfvac9x.js";
+
+// src/image.ts
+var exports_image = {};
+__export(exports_image, {
+  node: () => node,
+  SizeError: () => SizeError,
+  Service: () => Service,
+  ResizerUnavailableError: () => ResizerUnavailableError,
+  Image: () => exports_image,
+  DecodeError: () => DecodeError
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+class ResizerUnavailableError extends Schema.TaggedErrorClass()("Image.ResizerUnavailableError", {}) {
+}
+
+class DecodeError extends Schema.TaggedErrorClass()("Image.DecodeError", {
+  resource: Schema.String
+}) {
+  get message() {
+    return `Image could not be decoded: ${this.resource}`;
+  }
+}
+
+class SizeError extends Schema.TaggedErrorClass()("Image.SizeError", {
+  resource: Schema.String,
+  width: Schema.Number,
+  height: Schema.Number,
+  bytes: Schema.Number,
+  maxWidth: Schema.Number,
+  maxHeight: Schema.Number,
+  maxBytes: Schema.Number
+}) {
+  get message() {
+    return `Image ${this.resource} is ${this.width}x${this.height} with base64 size ${this.bytes}, exceeding configured limits ${this.maxWidth}x${this.maxHeight}/${this.maxBytes} bytes`;
+  }
+}
+
+class Service extends Context.Service()("@opencode/Image") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const config = yield* exports_config.Service;
+  const loadAdapter = yield* Effect.cached(Effect.tryPromise({
+    try: () => import("../image/photon.js"),
+    catch: () => new ResizerUnavailableError
+  }).pipe(Effect.flatMap((adapter) => adapter.make)));
+  const normalize = Effect.fn("Image.normalize")(function* (resource, content) {
+    const image = Object.assign({}, ...(yield* config.entries()).flatMap((entry) => entry.type === "document" && entry.info.media?.image ? [entry.info.media.image] : []));
+    const normalize2 = yield* loadAdapter;
+    return yield* normalize2(resource, content, {
+      autoResize: image.auto_resize ?? true,
+      maxWidth: image.max_width ?? 2000,
+      maxHeight: image.max_height ?? 2000,
+      maxBase64Bytes: image.max_base64_bytes ?? 5 * 1024 * 1024
+    });
+  });
+  return Service.of({ normalize });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_config.node] });
+
+export { ResizerUnavailableError, DecodeError, SizeError, Service, node, exports_image };

package/dist/chunks/location-mutation-fm1nvm5g.js

@@ -0,0 +1,32 @@
+import {
+  exports_provider
+} from "./location-mutation-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/location-mutation-fmh1wbpk.js

@@ -0,0 +1,194 @@
+import {
+  exports_provider
+} from "./location-mutation-18pv8fg3.js";
+import {
+  exports_command
+} from "./location-mutation-thstd87d.js";
+import {
+  exports_plugin
+} from "./location-mutation-9f0rnpkn.js";
+import {
+  exports_layout
+} from "./location-mutation-gcay93cp.js";
+import {
+  exports_mcp
+} from "./location-mutation-e1z9a0ts.js";
+import {
+  exports_server
+} from "./location-mutation-pq4b4pqk.js";
+import {
+  exports_formatter
+} from "./location-mutation-2nmyybe0.js";
+import {
+  exports_agent
+} from "./location-mutation-4s2xwh5d.js";
+import {
+  exports_permission
+} from "./location-mutation-v9bfv94f.js";
+import {
+  exports_skills
+} from "./location-mutation-nzrjycs5.js";
+import {
+  exports_attachment
+} from "./location-mutation-r3k9abhd.js";
+import {
+  exports_lsp
+} from "./location-mutation-999qd968.js";
+import {
+  NonNegativeInt,
+  PositiveInt
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/v1/config/config.ts
+var exports_config = {};
+__export(exports_config, {
+  WellKnown: () => WellKnown,
+  Info: () => Info,
+  ConfigV1: () => exports_config
+});
+import { Schema } from "effect";
+import { ConfigReference } from "@opencode-ai/schema/config/reference";
+var WellKnown = Schema.Struct({
+  config: Schema.optional(Schema.Json),
+  remote_config: Schema.optional(Schema.Json)
+});
+var LogLevelRef = Schema.Literals(["DEBUG", "INFO", "WARN", "ERROR"]).annotate({
+  identifier: "LogLevel",
+  description: "Log level"
+});
+var Info = Schema.Struct({
+  $schema: Schema.optional(Schema.String).annotate({
+    description: "JSON schema reference for configuration validation"
+  }),
+  shell: Schema.optional(Schema.String).annotate({ description: "Default shell to use for terminal and bash tool" }),
+  logLevel: Schema.optional(LogLevelRef).annotate({ description: "Log level" }),
+  server: Schema.optional(exports_server.Server).annotate({
+    description: "Server configuration for opencode serve and web commands"
+  }),
+  command: Schema.optional(Schema.Record(Schema.String, exports_command.Info)).annotate({
+    description: "Command configuration, see https://opencode.ai/docs/commands"
+  }),
+  skills: Schema.optional(exports_skills.Info).annotate({ description: "Additional skill folder paths" }),
+  references: Schema.optional(ConfigReference.Info).annotate({
+    description: "Named git or local directory references"
+  }),
+  reference: Schema.optional(ConfigReference.Info).annotate({
+    description: "@deprecated Use 'references' field instead. Named git or local directory references"
+  }),
+  watcher: Schema.optional(Schema.Struct({ ignore: Schema.optional(Schema.mutable(Schema.Array(Schema.String))) })),
+  snapshot: Schema.optional(Schema.Boolean).annotate({
+    description: "Enable or disable snapshot tracking. When false, filesystem snapshots are not recorded and undoing or reverting will not undo/redo file changes. Defaults to true."
+  }),
+  plugin: Schema.optional(Schema.mutable(Schema.Array(exports_plugin.Spec))),
+  share: Schema.optional(Schema.Literals(["manual", "auto", "disabled"])).annotate({
+    description: "Control sharing behavior:'manual' allows manual sharing via commands, 'auto' enables automatic sharing, 'disabled' disables all sharing"
+  }),
+  autoshare: Schema.optional(Schema.Boolean).annotate({
+    description: "@deprecated Use 'share' field instead. Share newly created sessions automatically"
+  }),
+  autoupdate: Schema.optional(Schema.Union([Schema.Boolean, Schema.Literal("notify")])).annotate({
+    description: "Automatically update to the latest version. Set to true to auto-update, false to disable, or 'notify' to show update notifications"
+  }),
+  disabled_providers: Schema.optional(Schema.mutable(Schema.Array(Schema.String))).annotate({
+    description: "Disable providers that are loaded automatically"
+  }),
+  enabled_providers: Schema.optional(Schema.mutable(Schema.Array(Schema.String))).annotate({
+    description: "When set, ONLY these providers will be enabled. All other providers will be ignored"
+  }),
+  model: Schema.optional(Schema.String).annotate({
+    description: "Model to use in the format of provider/model, eg anthropic/claude-2"
+  }),
+  small_model: Schema.optional(Schema.String).annotate({
+    description: "Small model to use for tasks like title generation in the format of provider/model"
+  }),
+  default_agent: Schema.optional(Schema.String).annotate({
+    description: "Default agent to use when none is specified. Must be a primary agent. Falls back to 'build' if not set or if the specified agent is invalid."
+  }),
+  subagent_depth: Schema.optional(NonNegativeInt).annotate({
+    description: "Maximum subagent nesting depth. Defaults to 1, which prevents subagents from launching subagents."
+  }),
+  username: Schema.optional(Schema.String).annotate({
+    description: "Custom username to display in conversations instead of system username"
+  }),
+  mode: Schema.optional(Schema.StructWithRest(Schema.Struct({ build: Schema.optional(exports_agent.Info), plan: Schema.optional(exports_agent.Info) }), [Schema.Record(Schema.String, exports_agent.Info)])).annotate({ description: "@deprecated Use `agent` field instead." }),
+  agent: Schema.optional(Schema.StructWithRest(Schema.Struct({
+    plan: Schema.optional(exports_agent.Info),
+    build: Schema.optional(exports_agent.Info),
+    general: Schema.optional(exports_agent.Info),
+    explore: Schema.optional(exports_agent.Info),
+    title: Schema.optional(exports_agent.Info),
+    summary: Schema.optional(exports_agent.Info),
+    compaction: Schema.optional(exports_agent.Info)
+  }), [Schema.Record(Schema.String, exports_agent.Info)])).annotate({ description: "Agent configuration, see https://opencode.ai/docs/agents" }),
+  provider: Schema.optional(Schema.Record(Schema.String, exports_provider.Info)).annotate({
+    description: "Custom provider configurations and model overrides"
+  }),
+  mcp: Schema.optional(Schema.Record(Schema.String, Schema.Union([exports_mcp.Info, Schema.Struct({ enabled: Schema.Boolean })]))).annotate({ description: "MCP (Model Context Protocol) server configurations" }),
+  formatter: Schema.optional(exports_formatter.Info).annotate({
+    description: "Enable or configure formatters. Omit or set to false to disable, true to enable built-ins, or an object to enable built-ins with overrides."
+  }),
+  lsp: Schema.optional(exports_lsp.Info).annotate({
+    description: "Enable or configure LSP servers. Omit or set to false to disable, true to enable built-ins, or an object to enable built-ins with overrides."
+  }),
+  instructions: Schema.optional(Schema.mutable(Schema.Array(Schema.String))).annotate({
+    description: "Additional instruction files or patterns to include"
+  }),
+  layout: Schema.optional(exports_layout.Layout).annotate({ description: "@deprecated Always uses stretch layout." }),
+  permission: Schema.optional(exports_permission.Info),
+  tools: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)),
+  attachment: Schema.optional(exports_attachment.Info).annotate({
+    description: "Attachment processing configuration, including image size limits and resizing behavior"
+  }),
+  enterprise: Schema.optional(Schema.Struct({ url: Schema.optional(Schema.String).annotate({ description: "Enterprise URL" }) })),
+  tool_output: Schema.optional(Schema.Struct({
+    max_lines: Schema.optional(PositiveInt).annotate({
+      description: "Maximum lines of tool output before it is truncated and saved to disk (default: 2000)"
+    }),
+    max_bytes: Schema.optional(PositiveInt).annotate({
+      description: "Maximum bytes of tool output before it is truncated and saved to disk (default: 51200)"
+    })
+  })).annotate({
+    description: "Thresholds for truncating tool output. When output exceeds either limit, the full text is written to the truncation directory and a preview is returned."
+  }),
+  compaction: Schema.optional(Schema.Struct({
+    auto: Schema.optional(Schema.Boolean).annotate({
+      description: "Enable automatic compaction when context is full (default: true)"
+    }),
+    prune: Schema.optional(Schema.Boolean).annotate({
+      description: "Enable pruning of old tool outputs (default: false)"
+    }),
+    tail_turns: Schema.optional(NonNegativeInt).annotate({
+      description: "Number of recent user turns, including their following assistant/tool responses, to keep verbatim during compaction (default: 2)"
+    }),
+    preserve_recent_tokens: Schema.optional(NonNegativeInt).annotate({
+      description: "Maximum number of tokens from recent turns to preserve verbatim after compaction"
+    }),
+    reserved: Schema.optional(NonNegativeInt).annotate({
+      description: "Token buffer for compaction. Leaves enough window to avoid overflow during compaction."
+    })
+  })),
+  experimental: Schema.optional(Schema.Struct({
+    disable_paste_summary: Schema.optional(Schema.Boolean),
+    batch_tool: Schema.optional(Schema.Boolean).annotate({ description: "Enable the batch tool" }),
+    openTelemetry: Schema.optional(Schema.Boolean).annotate({
+      description: "Enable OpenTelemetry spans for AI SDK calls (using the 'experimental_telemetry' flag)"
+    }),
+    primary_tools: Schema.optional(Schema.mutable(Schema.Array(Schema.String))).annotate({
+      description: "Tools that should only be available to primary agents."
+    }),
+    subagent_depth: Schema.optional(NonNegativeInt).annotate({
+      description: "Maximum subagent nesting depth. Defaults to 1."
+    }),
+    continue_loop_on_deny: Schema.optional(Schema.Boolean).annotate({
+      description: "Continue the agent loop when a tool call is denied"
+    }),
+    mcp_timeout: Schema.optional(PositiveInt).annotate({
+      description: "Timeout in milliseconds for model context protocol (MCP) requests"
+    })
+  }))
+}).annotate({ identifier: "Config" });
+
+export { WellKnown, Info, exports_config };

package/dist/chunks/location-mutation-fmyre8m1.js

@@ -0,0 +1,24 @@
+import {
+  __require
+} from "./location-mutation-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/location-mutation-fvhse3q1.js

@@ -0,0 +1,35 @@
+import {
+  DefaultServices,
+  EffectSQLiteDatabase,
+  make,
+  makeWithDefaults
+} from "./location-mutation-g3by6dpw.js";
+import {
+  EffectSQLiteSession,
+  EffectSQLiteTransaction,
+  managesTransactionsNatively
+} from "./location-mutation-mj57afrc.js";
+import {
+  migrate
+} from "./location-mutation-w35hs5me.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/database/drizzle/index.ts
+var exports_drizzle = {};
+__export(exports_drizzle, {
+  migrate: () => migrate,
+  managesTransactionsNatively: () => managesTransactionsNatively,
+  makeWithDefaults: () => makeWithDefaults,
+  make: () => make,
+  EffectSQLiteTransaction: () => EffectSQLiteTransaction,
+  EffectSQLiteSession: () => EffectSQLiteSession,
+  EffectSQLiteDatabase: () => EffectSQLiteDatabase,
+  EffectLogger: () => EffectLogger,
+  EffectDrizzleSqlite: () => exports_drizzle,
+  DefaultServices: () => DefaultServices
+});
+import { EffectLogger } from "drizzle-orm/effect-core";
+
+export { exports_drizzle, EffectLogger };

package/dist/chunks/location-mutation-g2tksnm3.js

@@ -0,0 +1,137 @@
+import {
+  SQLiteEffectInsertBuilder
+} from "./location-mutation-erj4j75s.js";
+import {
+  SQLiteEffectCountBuilder
+} from "./location-mutation-0f48qthw.js";
+import {
+  SQLiteEffectUpdateBuilder
+} from "./location-mutation-zfxc0ze5.js";
+import {
+  SQLiteEffectRaw
+} from "./location-mutation-s7whb9gt.js";
+import {
+  SQLiteEffectDeleteBase
+} from "./location-mutation-g9yygpzr.js";
+import {
+  SQLiteEffectSelectBuilder
+} from "./location-mutation-mwceq5am.js";
+import {
+  SQLiteEffectRelationalQueryBuilder
+} from "./location-mutation-bxdhjb3y.js";
+
+// src/database/drizzle/sqlite-core/effect/db.ts
+import { Effect } from "effect";
+import { entityKind } from "drizzle-orm/entity";
+import { SelectionProxyHandler } from "drizzle-orm/selection-proxy";
+import { sql } from "drizzle-orm/sql/sql";
+import { QueryBuilder } from "drizzle-orm/sqlite-core/query-builders/query-builder";
+import { WithSubquery } from "drizzle-orm/subquery";
+class SQLiteEffectDatabase {
+  dialect;
+  session;
+  rowModeRQB;
+  forbidJsonb;
+  static [entityKind] = "SQLiteEffectDatabase";
+  query;
+  constructor(dialect, session, relations, rowModeRQB, forbidJsonb) {
+    this.dialect = dialect;
+    this.session = session;
+    this.rowModeRQB = rowModeRQB;
+    this.forbidJsonb = forbidJsonb;
+    this._ = {
+      relations,
+      session
+    };
+    this.query = {};
+    for (const [tableName, relation] of Object.entries(relations)) {
+      this.query[tableName] = new SQLiteEffectRelationalQueryBuilder(relations, relations[relation.name].table, relation, dialect, session, rowModeRQB, forbidJsonb);
+    }
+    this.$cache = {
+      invalidate: (_params) => Effect.void
+    };
+  }
+  $with = (alias, selection) => {
+    const self = this;
+    const as = (qb) => {
+      if (typeof qb === "function") {
+        qb = qb(new QueryBuilder(self.dialect));
+      }
+      return new Proxy(new WithSubquery(qb.getSQL(), selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}), alias, true), new SelectionProxyHandler({ alias, sqlAliasedBehavior: "alias", sqlBehavior: "error" }));
+    };
+    return { as };
+  };
+  $cache;
+  $count(source, filters) {
+    return new SQLiteEffectCountBuilder({ source, filters, session: this.session });
+  }
+  with(...queries) {
+    const self = this;
+    function select(fields) {
+      return new SQLiteEffectSelectBuilder({
+        fields: fields ?? undefined,
+        session: self.session,
+        dialect: self.dialect,
+        withList: queries
+      });
+    }
+    function selectDistinct(fields) {
+      return new SQLiteEffectSelectBuilder({
+        fields: fields ?? undefined,
+        session: self.session,
+        dialect: self.dialect,
+        withList: queries,
+        distinct: true
+      });
+    }
+    function update(table) {
+      return new SQLiteEffectUpdateBuilder(table, self.session, self.dialect, queries);
+    }
+    function insert(into) {
+      return new SQLiteEffectInsertBuilder(into, self.session, self.dialect, queries);
+    }
+    function delete_(from) {
+      return new SQLiteEffectDeleteBase(from, self.session, self.dialect, queries);
+    }
+    return { select, selectDistinct, update, insert, delete: delete_ };
+  }
+  select(fields) {
+    return new SQLiteEffectSelectBuilder({ fields: fields ?? undefined, session: this.session, dialect: this.dialect });
+  }
+  selectDistinct(fields) {
+    return new SQLiteEffectSelectBuilder({
+      fields: fields ?? undefined,
+      session: this.session,
+      dialect: this.dialect,
+      distinct: true
+    });
+  }
+  update(table) {
+    return new SQLiteEffectUpdateBuilder(table, this.session, this.dialect);
+  }
+  insert(into) {
+    return new SQLiteEffectInsertBuilder(into, this.session, this.dialect);
+  }
+  delete(from) {
+    return new SQLiteEffectDeleteBase(from, this.session, this.dialect);
+  }
+  raw(query, action, execute) {
+    const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
+    return new SQLiteEffectRaw(() => execute(sequel), () => sequel, action, this.dialect, (result) => result);
+  }
+  run(query) {
+    return this.raw(query, "run", (sequel) => this.session.run(sequel));
+  }
+  all(query) {
+    return this.raw(query, "all", (sequel) => this.session.all(sequel));
+  }
+  get(query) {
+    return this.raw(query, "get", (sequel) => this.session.get(sequel));
+  }
+  values(query) {
+    return this.raw(query, "values", (sequel) => this.session.values(sequel));
+  }
+  transaction = (tx, config) => this.session.transaction(tx, config);
+}
+
+export { SQLiteEffectDatabase };

package/dist/chunks/location-mutation-g3by6dpw.js

@@ -0,0 +1,41 @@
+import {
+  EffectSQLiteSession
+} from "./location-mutation-mj57afrc.js";
+import {
+  SQLiteEffectDatabase
+} from "./location-mutation-g2tksnm3.js";
+import {
+  jitCompatCheck
+} from "./location-mutation-ma07p6tt.js";
+
+// src/database/drizzle/effect-sqlite/driver.ts
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { EffectCache } from "drizzle-orm/cache/core/cache-effect";
+import { EffectLogger } from "drizzle-orm/effect-core";
+import { entityKind } from "drizzle-orm/entity";
+import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core/dialect";
+class EffectSQLiteDatabase extends SQLiteEffectDatabase {
+  static [entityKind] = "EffectSQLiteDatabase";
+}
+var DefaultServices = Layer.merge(EffectCache.Default, EffectLogger.Default);
+var make = Effect.fn("SQLiteDrizzle.make")(function* (config = {}) {
+  const client = yield* SqlClient;
+  const cache = yield* EffectCache;
+  const logger = yield* EffectLogger;
+  const dialect = new SQLiteAsyncDialect;
+  const relations = config.relations ?? {};
+  const session = new EffectSQLiteSession(client, dialect, relations, {
+    logger,
+    cache,
+    useJitMappers: jitCompatCheck(config.jit)
+  });
+  const db = new EffectSQLiteDatabase(dialect, session, relations);
+  db.$client = client;
+  db.$cache.invalidate = cache.onMutate;
+  return db;
+});
+var makeWithDefaults = (config = {}) => make(config).pipe(Effect.provide(DefaultServices));
+
+export { EffectSQLiteDatabase, DefaultServices, make, makeWithDefaults };

package/dist/chunks/location-mutation-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 };