@opencode-ai/core 0.0.0-dev-19092 → 0.0.0-dev-19094

package/dist/chunks/command-vvhr8ap4.js

@@ -0,0 +1,153 @@
+import {
+  Service80,
+  node84
+} from "./command-mh85gtv1.js";
+import {
+  Service79,
+  node83
+} from "./command-pdae5shs.js";
+import {
+  CredentialTable2
+} from "./command-pknna89w.js";
+import {
+  __export
+} from "./command-9rqn6x4v.js";
+
+// src/credential.ts
+var exports_credential = {};
+__export(exports_credential, {
+  Credential: () => exports_credential,
+  Event: () => Event19,
+  ID: () => ID16,
+  Info: () => Info30,
+  Key: () => Key4,
+  OAuth: () => OAuth3,
+  Service: () => Service75,
+  Value: () => Value2,
+  node: () => node78
+});
+import { asc, desc, eq } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Credential } from "@opencode-ai/schema/credential";
+import { Integration } from "@opencode-ai/schema/integration";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+var ID16 = Credential.ID;
+var OAuth3 = Credential.OAuth;
+var Key4 = Credential.Key;
+var Value2 = Credential.Value;
+var Event19 = Credential.Event;
+
+class Info30 extends Schema.Class("Credential.Info")({
+  id: ID16,
+  integrationID: Integration.ID,
+  label: Schema.String,
+  value: Value2
+}) {
+}
+
+class Service75 extends Context.Service()("@opencode/Credential") {
+}
+var layer = Layer.effect(Service75, Effect.gen(function* () {
+  const db = (yield* Service80).db;
+  const bus = yield* Service79;
+  const decode = Schema.decodeUnknownSync(Value2);
+  const stored = (row) => {
+    if (!row.integration_id)
+      return;
+    return new Info30({
+      id: row.id,
+      integrationID: row.integration_id,
+      label: row.label,
+      value: decode(row.value)
+    });
+  };
+  const storedRows = (rows) => rows.flatMap((row) => {
+    const credential = stored(row);
+    return credential ? [credential] : [];
+  });
+  return Service75.of({
+    all: Effect.fn("Credential.all")(() => db.select().from(CredentialTable2).orderBy(asc(CredentialTable2.active), asc(CredentialTable2.time_created), asc(CredentialTable2.id)).all().pipe(Effect.orDie, Effect.map(storedRows))),
+    list: Effect.fn("Credential.list")((integrationID) => db.select().from(CredentialTable2).where(eq(CredentialTable2.integration_id, integrationID)).orderBy(asc(CredentialTable2.active), asc(CredentialTable2.time_created), asc(CredentialTable2.id)).all().pipe(Effect.orDie, Effect.map(storedRows))),
+    get: Effect.fn("Credential.get")(function* (id) {
+      const row = yield* db.select().from(CredentialTable2).where(eq(CredentialTable2.id, id)).get().pipe(Effect.orDie);
+      return row ? stored(row) : undefined;
+    }),
+    create: Effect.fn("Credential.create")(function* (input) {
+      const credential = new Info30({
+        id: ID16.create(),
+        integrationID: input.integrationID,
+        label: input.label ?? "default",
+        value: input.value
+      });
+      yield* db.transaction((tx) => Effect.gen(function* () {
+        yield* tx.update(CredentialTable2).set({ active: false }).where(eq(CredentialTable2.integration_id, credential.integrationID)).run();
+        yield* tx.insert(CredentialTable2).values({
+          id: credential.id,
+          integration_id: credential.integrationID,
+          label: credential.label,
+          value: credential.value,
+          active: true
+        }).run();
+      })).pipe(Effect.orDie);
+      yield* bus.publish(Event19.Updated, {}, { global: true });
+      yield* bus.publish(Event19.Switched, { integrationID: credential.integrationID, credentialID: credential.id }, { global: true });
+      return credential;
+    }),
+    activate: Effect.fn("Credential.activate")(function* (id) {
+      const integrationID = yield* db.transaction((tx) => Effect.gen(function* () {
+        const credential = yield* tx.select().from(CredentialTable2).where(eq(CredentialTable2.id, id)).get();
+        if (!credential?.integration_id)
+          return;
+        const active = yield* tx.select({ id: CredentialTable2.id }).from(CredentialTable2).where(eq(CredentialTable2.integration_id, credential.integration_id)).orderBy(desc(CredentialTable2.active), desc(CredentialTable2.time_created), desc(CredentialTable2.id)).get();
+        if (active?.id === id)
+          return;
+        yield* tx.update(CredentialTable2).set({ active: false }).where(eq(CredentialTable2.integration_id, credential.integration_id)).run();
+        yield* tx.update(CredentialTable2).set({ active: true }).where(eq(CredentialTable2.id, id)).run();
+        return credential.integration_id;
+      })).pipe(Effect.orDie);
+      if (integrationID)
+        yield* bus.publish(Event19.Switched, { integrationID, credentialID: id }, { global: true });
+    }),
+    update: Effect.fn("Credential.update")(function* (id, updates) {
+      if (updates.label === undefined && updates.value === undefined)
+        return;
+      const credential = yield* db.select({ integrationID: CredentialTable2.integration_id, label: CredentialTable2.label }).from(CredentialTable2).where(eq(CredentialTable2.id, id)).get().pipe(Effect.orDie);
+      if (!credential?.integrationID)
+        return;
+      if (updates.label === credential.label && updates.value === undefined)
+        return;
+      yield* db.update(CredentialTable2).set({ label: updates.label, value: updates.value }).where(eq(CredentialTable2.id, id)).run().pipe(Effect.orDie);
+      if (updates.label !== undefined && updates.label !== credential.label)
+        yield* bus.publish(Event19.Updated, {}, { global: true });
+    }),
+    remove: Effect.fn("Credential.remove")(function* (id) {
+      const removed = yield* db.transaction((tx) => Effect.gen(function* () {
+        const credential = yield* tx.select().from(CredentialTable2).where(eq(CredentialTable2.id, id)).get();
+        if (!credential)
+          return;
+        const active = credential.integration_id ? yield* tx.select({ id: CredentialTable2.id }).from(CredentialTable2).where(eq(CredentialTable2.integration_id, credential.integration_id)).orderBy(desc(CredentialTable2.active), desc(CredentialTable2.time_created), desc(CredentialTable2.id)).get() : undefined;
+        yield* tx.delete(CredentialTable2).where(eq(CredentialTable2.id, id)).run();
+        if (!credential.integration_id || active?.id !== id)
+          return { switched: false };
+        const replacement = yield* tx.select({ id: CredentialTable2.id }).from(CredentialTable2).where(eq(CredentialTable2.integration_id, credential.integration_id)).orderBy(desc(CredentialTable2.time_created), desc(CredentialTable2.id)).get();
+        if (replacement) {
+          yield* tx.update(CredentialTable2).set({ active: false }).where(eq(CredentialTable2.integration_id, credential.integration_id)).run();
+          yield* tx.update(CredentialTable2).set({ active: true }).where(eq(CredentialTable2.id, replacement.id)).run();
+        }
+        return {
+          switched: true,
+          integrationID: credential.integration_id,
+          credentialID: replacement?.id ?? null
+        };
+      })).pipe(Effect.orDie);
+      if (!removed)
+        return;
+      yield* bus.publish(Event19.Updated, {}, { global: true });
+      if (removed.switched)
+        yield* bus.publish(Event19.Switched, { integrationID: removed.integrationID, credentialID: removed.credentialID }, { global: true });
+    })
+  });
+}));
+var node78 = makeGlobalNode({ service: Service75, layer, deps: [node84, node83] });
+
+export { ID16, OAuth3, Key4, Value2, Event19, Info30, Service75, node78, exports_credential };

package/dist/chunks/{integration-5wdfcf64.js → command-vw50vsx1.js}

@@ -1,21 +1,22 @@
 import {
-  exports_mcp
-} from "./integration-b5zj5y7v.js";
+  Service79
+} from "./command-pdae5shs.js";
 import {
-  exports_location
-} from "./integration-gpa7n6yh.js";
+  Service68
+} from "./command-4jcgzkct.js";
 import {
-  exports_bus
-} from "./integration-hf9h67zk.js";
+  PromptsChanged2,
+  Service36
+} from "./command-pcednt3p.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/plugin/command.ts
 var exports_command = {};
 __export(exports_command, {
   CommandPlugin: () => exports_command,
-  Plugin: () => Plugin
+  Plugin: () => Plugin14
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect, Stream } from "effect";
@@ -192,14 +193,14 @@ If you're uncertain about something and can't verify it with these tools, say "I
 `;
 
 // src/plugin/command.ts
-var Plugin = define({
+var Plugin14 = define({
   id: "opencode.command",
   effect: Effect.fn(function* (ctx) {
-    const location = yield* exports_location.Service;
-    const mcp = yield* exports_mcp.Service;
-    const bus = yield* exports_bus.Service;
+    const location = yield* Service68;
+    const mcp = yield* Service36;
+    const bus = yield* Service79;
     const loaded = { prompts: [] };
-    yield* bus.subscribe(exports_mcp.PromptsChanged).pipe(Stream.runForEach(() => mcp.prompts().pipe(Effect.tap((prompts) => Effect.sync(() => loaded.prompts = prompts)), Effect.andThen(ctx.command.reload()))), Effect.forkScoped({ startImmediately: true }));
+    yield* bus.subscribe(PromptsChanged2).pipe(Stream.runForEach(() => mcp.prompts().pipe(Effect.tap((prompts) => Effect.sync(() => loaded.prompts = prompts)), Effect.andThen(ctx.command.reload()))), Effect.forkScoped({ startImmediately: true }));
     loaded.prompts = yield* mcp.prompts();
     yield* ctx.command.transform((editor) => {
       editor.add({
@@ -279,4 +280,4 @@ function sanitize(value) {
 var argsRegex = /(?:\[Image\s+\d+\]|"[^"]*"|'[^']*'|[^\s"']+)/gi;
 var quoteTrimRegex = /^["']|["']$/g;
 
-export { Plugin, exports_command };
+export { Plugin14, exports_command };

package/dist/chunks/{integration-gaj0yc80.js → command-w0117ta3.js}

@@ -1,48 +1,49 @@
 import {
-  exports_bus
-} from "./integration-hf9h67zk.js";
+  Service79,
+  node83
+} from "./command-pdae5shs.js";
 import {
-  exports_state
-} from "./integration-j6s3yjyb.js";
+  create3
+} from "./command-kg06axw8.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/command.ts
-var exports_command = {};
-__export(exports_command, {
-  Command: () => exports_command,
-  Event: () => Event,
-  ExecutionError: () => ExecutionError,
-  Info: () => Info,
-  NotFoundError: () => NotFoundError,
-  Service: () => Service,
-  layer: () => layer,
-  node: () => node
+var exports_command5 = {};
+__export(exports_command5, {
+  Command: () => exports_command5,
+  Event: () => Event13,
+  ExecutionError: () => ExecutionError2,
+  Info: () => Info23,
+  NotFoundError: () => NotFoundError8,
+  Service: () => Service65,
+  layer: () => layer22,
+  node: () => node67
 });
 import { Command } from "@opencode-ai/schema/command";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";
-import { Event } from "@opencode-ai/schema/command";
-var Info = Command.Info;
+import { Event as Event13 } from "@opencode-ai/schema/command";
+var Info23 = Command.Info;
 
-class NotFoundError extends Schema.TaggedError()("Command.NotFoundError", {
+class NotFoundError8 extends Schema.TaggedError()("Command.NotFoundError", {
   command: Schema.String,
   message: Schema.String
 }) {
 }
 
-class ExecutionError extends Schema.TaggedError()("Command.ExecutionError", {
+class ExecutionError2 extends Schema.TaggedError()("Command.ExecutionError", {
   command: Schema.String,
   message: Schema.String
 }) {
 }
 
-class Service extends Context.Service()("@opencode/Command") {
+class Service65 extends Context.Service()("@opencode/Command") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const bus = yield* exports_bus.Service;
-  const state = exports_state.create({
+var layer22 = Layer.effect(Service65, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const state = create3({
     name: "command",
     initial: () => new Map,
     editor: (editor) => ({
@@ -50,11 +51,11 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     }),
     notify: () => bus.publish(Command.Event.Updated, {}).pipe(Effect.asVoid)
   });
-  const info = (definition) => Info.make({
+  const info = (definition) => Info23.make({
     name: definition.name,
     description: definition.description
   });
-  return Service.of({
+  return Service65.of({
     reload: state.reload,
     transform: state.transform,
     get: Effect.fn("Command.get")((name) => Effect.sync(() => {
@@ -65,15 +66,15 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     execute: Effect.fn("Command.execute")(function* (input) {
       const definition = state.get().get(input.name);
       if (!definition)
-        return yield* new NotFoundError({ command: input.name, message: `Command not found: ${input.name}` });
-      return yield* definition.execute(input.invocation).pipe(Effect.tapError((error) => Effect.logError("command execution failed", { command: input.name, error })), Effect.mapError((error) => new ExecutionError({ command: input.name, message: errorMessage(error) })));
+        return yield* new NotFoundError8({ command: input.name, message: `Command not found: ${input.name}` });
+      return yield* definition.execute(input.invocation).pipe(Effect.tapError((error) => Effect.logError("command execution failed", { command: input.name, error })), Effect.mapError((error) => new ExecutionError2({ command: input.name, message: errorMessage(error) })));
     })
   });
 }));
-var node = makeLocationNode({
-  service: Service,
-  layer,
-  deps: [exports_bus.node]
+var node67 = makeLocationNode({
+  service: Service65,
+  layer: layer22,
+  deps: [node83]
 });
 function errorMessage(error) {
   if (error instanceof Error)
@@ -85,4 +86,4 @@ function errorMessage(error) {
   return "Command execution failed";
 }
 
-export { Info, NotFoundError, ExecutionError, Service, layer, node, exports_command, Event };
+export { Info23, NotFoundError8, ExecutionError2, Service65, layer22, node67, exports_command5, Event13 };

package/dist/chunks/{integration-a4q051z4.js → command-w16pqxss.js}

@@ -1,26 +1,32 @@
 import {
-  exports_mcp as exports_mcp2
-} from "./integration-8jedcdnq.js";
+  Key3,
+  removed2,
+  empty3,
+  make18,
+  diffByKey2
+} from "./command-mtcjf44p.js";
 import {
-  exports_mcp
-} from "./integration-b5zj5y7v.js";
+  evaluate2
+} from "./command-nkpkrkfc.js";
 import {
-  exports_permission
-} from "./integration-44nx66ev.js";
+  Service36,
+  node38
+} from "./command-pcednt3p.js";
 import {
-  exports_instructions
-} from "./integration-c54e84vp.js";
+  namespace2,
+  name14
+} from "./command-njfhyprf.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/mcp/instructions.ts
-var exports_instructions2 = {};
-__export(exports_instructions2, {
-  McpInstructions: () => exports_instructions2,
-  Service: () => Service,
-  layer: () => layer,
-  node: () => node
+var exports_instructions4 = {};
+__export(exports_instructions4, {
+  McpInstructions: () => exports_instructions4,
+  Service: () => Service23,
+  layer: () => layer10,
+  node: () => node27
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";
@@ -32,7 +38,7 @@ var Summary = Schema.Struct({
 var entries = (servers) => servers.flatMap((server) => {
   const result = [`  <server name="${server.server}">`];
   if (server.codemode !== false)
-    result.push(`    Use tools from this server through \`execute\` under \`tools[${JSON.stringify(exports_mcp2.namespace(server.server))}]\`.`);
+    result.push(`    Use tools from this server through \`execute\` under \`tools[${JSON.stringify(namespace2(server.server))}]\`.`);
   result.push(...server.instructions.split(`
 `).map((line) => `    ${line}`), "  </server>");
   return result;
@@ -40,7 +46,7 @@ var entries = (servers) => servers.flatMap((server) => {
 var render = (servers) => ["<mcp_instructions>", ...entries(servers), "</mcp_instructions>"].join(`
 `);
 var update = (previous, current) => {
-  const diff = exports_instructions.diffByKey(previous, current, (server) => server.server, (before, after) => before.instructions !== after.instructions || before.codemode !== after.codemode);
+  const diff = diffByKey2(previous, current, (server) => server.server, (before, after) => before.instructions !== after.instructions || before.codemode !== after.codemode);
   if (diff.changed.length > 0 || diff.added.length === 0 && diff.removed.length === 0)
     return [
       "The available MCP server instructions have changed. This list supersedes the previous one.",
@@ -56,17 +62,17 @@ var update = (previous, current) => {
 `);
 };
 
-class Service extends Context.Service()("@opencode/McpInstructions") {
+class Service23 extends Context.Service()("@opencode/McpInstructions") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const mcp = yield* exports_mcp.Service;
-  return Service.of({
+var layer10 = Layer.effect(Service23, Effect.gen(function* () {
+  const mcp = yield* Service36;
+  return Service23.of({
     load: Effect.fn("McpInstructions.load")(function* (selection) {
       const agent = selection.info;
       if (!agent)
-        return exports_instructions.empty;
-      const source = (value) => exports_instructions.make({
-        key: exports_instructions.Key.make("core/mcp-guidance"),
+        return empty3;
+      const source = (value) => make18({
+        key: Key3.make("core/mcp-guidance"),
         codec: Schema.toCodecJson(Schema.Array(Summary)),
         read: Effect.succeed(value),
         render: {
@@ -78,22 +84,22 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       const [instructions, tools] = yield* Effect.all([mcp.instructions(), mcp.tools()], {
         concurrency: "unbounded"
       });
-      const canExecute = exports_permission.evaluate("execute", "*", agent.permissions).effect !== "deny";
+      const canExecute = evaluate2("execute", "*", agent.permissions).effect !== "deny";
       const visible = instructions.flatMap((item) => {
         const owned = tools.filter((tool) => tool.server === item.server);
         const codemode = owned[0]?.codemode !== false;
         if (codemode && !canExecute)
           return [];
-        if (!owned.some((tool) => exports_permission.evaluate(exports_mcp2.name(tool.server, tool.name), "*", agent.permissions).effect !== "deny"))
+        if (!owned.some((tool) => evaluate2(name14(tool.server, tool.name), "*", agent.permissions).effect !== "deny"))
           return [];
         return [
           codemode ? { server: item.server, instructions: item.instructions } : { server: item.server, instructions: item.instructions, codemode: false }
         ];
       }).toSorted((a, b) => a.server.localeCompare(b.server));
-      return source(visible.length === 0 ? exports_instructions.removed : visible);
+      return source(visible.length === 0 ? removed2 : visible);
     })
   });
 }));
-var node = makeLocationNode({ service: Service, layer, deps: [exports_mcp.node] });
+var node27 = makeLocationNode({ service: Service23, layer: layer10, deps: [node38] });
 
-export { Service, layer, node, exports_instructions2 as exports_instructions };
+export { Service23, layer10, node27, exports_instructions4 };

package/dist/chunks/{integration-0crzmh3d.js → command-w21nff9d.js}

@@ -1,70 +1,74 @@
 import {
-  exports_skill
-} from "./integration-r2xkd8e4.js";
+  Service42
+} from "./command-nkpkrkfc.js";
 import {
-  exports_permission
-} from "./integration-44nx66ev.js";
+  ID3,
+  Name2,
+  toModelOutput3,
+  prepare3,
+  Service41
+} from "./command-854ca1e8.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/tool/plugin/skill.ts
-var exports_skill2 = {};
-__export(exports_skill2, {
-  Input: () => Input,
-  Output: () => Output,
-  Plugin: () => Plugin,
-  SkillTool: () => exports_skill2,
-  description: () => description,
-  name: () => name,
-  toModelOutput: () => toModelOutput
+var exports_skill3 = {};
+__export(exports_skill3, {
+  Input: () => Input2,
+  Output: () => Output2,
+  Plugin: () => Plugin32,
+  SkillTool: () => exports_skill3,
+  description: () => description2,
+  name: () => name2,
+  toModelOutput: () => toModelOutput2
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { Effect, Schema } from "effect";
 import { FSUtil } from "@opencode-ai/util/fs-util";
-var name = "skill";
-var Input = Schema.Struct({
-  id: exports_skill.ID.annotate({ description: "The ID of an available skill or a skill explicitly referenced by the user" })
+var name2 = "skill";
+var Input2 = Schema.Struct({
+  id: ID3.annotate({ description: "The ID of an available skill or a skill explicitly referenced by the user" })
 });
-var Output = Schema.Struct({
-  name: exports_skill.Name,
+var Output2 = Schema.Struct({
+  name: Name2,
   directory: Schema.String,
   output: Schema.String
 });
-var description = [
+var description2 = [
   "Load a specialized skill's instructions and resources into the current conversation when the task at hand matches its description.",
   "",
   "The skill ID must match an available skill or a skill explicitly referenced by the user."
 ].join(`
 `);
-var toModelOutput = exports_skill.toModelOutput;
-var unableToLoad = (name2, error) => new ToolFailure({ message: `Unable to load skill ${name2}`, error });
-var Plugin = {
+var toModelOutput2 = toModelOutput3;
+var unableToLoad = (name, error) => new ToolFailure({ message: `Unable to load skill ${name}`, error });
+var Plugin32 = {
   id: "opencode.tool.skill",
   effect: Effect.fn("SkillTool.Plugin")(function* (ctx) {
     const fs = yield* FSUtil.Service;
-    const skills = yield* exports_skill.Service;
-    const permission = yield* exports_permission.Service;
+    const skills = yield* Service41;
+    const permission = yield* Service42;
     yield* ctx.tool.transform((editor) => editor.add({
-      name,
+      name: name2,
       options: { codemode: false },
-      description,
-      input: Input,
-      output: Output,
+      description: description2,
+      input: Input2,
+      output: Output2,
       execute: (input, context) => Effect.gen(function* () {
         const skill = yield* skills.get(input.id);
         if (!skill)
           return yield* unableToLoad(input.id);
         return yield* Effect.gen(function* () {
           yield* permission.assert({
-            action: name,
+            action: name2,
             resources: [skill.id],
             save: [skill.id],
             sessionID: context.sessionID,
             agent: context.agent,
             source: { type: "tool", messageID: context.messageID, id: context.id }
           });
-          return { name: skill.name, ...yield* exports_skill.prepare(fs, skill) };
+          return { name: skill.name, ...yield* prepare3(fs, skill) };
         }).pipe(Effect.mapError((error) => unableToLoad(input.id, error)));
       }).pipe(Effect.map((output) => ({
         output,
@@ -75,4 +79,4 @@ var Plugin = {
   })
 };
 
-export { name, Input, Output, description, toModelOutput, Plugin, exports_skill2 as exports_skill };
+export { name2, Input2, Output2, description2, toModelOutput2, Plugin32, exports_skill3 };

package/dist/chunks/{integration-vcwr2vpf.js → command-w3wsvvr9.js}

@@ -1,14 +1,14 @@
 import {
-  getTableColumnsRuntime,
-  orderSelectedFields
-} from "./integration-k8b45nas.js";
+  getTableColumnsRuntime2,
+  orderSelectedFields2
+} from "./command-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 SQLiteEffectDeleteBase {
+class SQLiteEffectDeleteBase2 {
   table;
   effectSession;
   effectDialect;
@@ -26,7 +26,7 @@ class SQLiteEffectDeleteBase {
   }
   orderBy(...columns) {
     if (typeof columns[0] === "function") {
-      const orderBy = columns[0](new Proxy(getTableColumnsRuntime(this.config.table), new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })));
+      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;
     }
@@ -37,8 +37,8 @@ class SQLiteEffectDeleteBase {
     this.config.limit = limit;
     return this;
   }
-  returning(fields = getTableColumnsRuntime(this.table)) {
-    this.config.returning = orderSelectedFields(fields);
+  returning(fields = getTableColumnsRuntime2(this.table)) {
+    this.config.returning = orderSelectedFields2(fields);
     return this;
   }
   getSQL() {
@@ -75,6 +75,6 @@ class SQLiteEffectDeleteBase {
     return this;
   }
 }
-applyEffectWrapper(SQLiteEffectDeleteBase);
+applyEffectWrapper(SQLiteEffectDeleteBase2);
 
-export { SQLiteEffectDeleteBase };
+export { SQLiteEffectDeleteBase2 };

package/dist/chunks/{integration-wbkt8qpj.js → command-wd87259q.js}

@@ -1,7 +1,7 @@
 import {
-  getViewSelectedFieldsRuntime,
-  orderSelectedFields
-} from "./integration-k8b45nas.js";
+  getViewSelectedFieldsRuntime2,
+  orderSelectedFields2
+} from "./command-emrn6kk6.js";
 
 // src/database/drizzle/sqlite-core/effect/select.ts
 import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
@@ -11,7 +11,7 @@ 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 SQLiteEffectSelectBuilder {
+class SQLiteEffectSelectBuilder2 {
   static [entityKind] = "SQLiteEffectSelectBuilder";
   fields;
   session;
@@ -36,13 +36,13 @@ class SQLiteEffectSelectBuilder {
         source[key]
       ]));
     } else if (is(source, SQLiteViewBase)) {
-      fields = getViewSelectedFieldsRuntime(source).selectedFields;
+      fields = getViewSelectedFieldsRuntime2(source).selectedFields;
     } else if (is(source, SQL)) {
       fields = {};
     } else {
       fields = getTableColumns(source);
     }
-    return new SQLiteEffectSelectBase({
+    return new SQLiteEffectSelectBase2({
       table: source,
       fields,
       isPartialSelect,
@@ -54,7 +54,7 @@ class SQLiteEffectSelectBuilder {
   }
 }
 
-class SQLiteEffectSelectBase extends SQLiteSelectBase {
+class SQLiteEffectSelectBase2 extends SQLiteSelectBase {
   static [entityKind] = "SQLiteEffectSelect";
   get effectConfig() {
     return this.config;
@@ -67,7 +67,7 @@ class SQLiteEffectSelectBase extends SQLiteSelectBase {
       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()), orderSelectedFields(this.effectConfig.fields), "all", undefined, {
+    const query = session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.dialect.sqlToQuery(this.getSQL()), orderSelectedFields2(this.effectConfig.fields), "all", undefined, {
       type: "select",
       tables: [...this.usedTables]
     }, this.cacheConfig);
@@ -97,6 +97,6 @@ class SQLiteEffectSelectBase extends SQLiteSelectBase {
     return this._prepare().execute(placeholderValues);
   };
 }
-applyEffectWrapper(SQLiteEffectSelectBase);
+applyEffectWrapper(SQLiteEffectSelectBase2);
 
-export { SQLiteEffectSelectBuilder, SQLiteEffectSelectBase };
+export { SQLiteEffectSelectBuilder2, SQLiteEffectSelectBase2 };