@opencode-ai/core 0.0.0-beta-19086 → 0.0.0-beta-19129

package/dist/chunks/{schema-svrgfpe2.js → pty-6tf8tr4v.js}

@@ -1,17 +1,17 @@
 import {
-  definition,
-  normalizedName
-} from "./schema-xx9qfgev.js";
+  definition2,
+  normalizedName2
+} from "./pty-3t738kvx.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/codemode/tool.ts
-var exports_tool = {};
-__export(exports_tool, {
-  CodeModeTool: () => exports_tool,
-  catalog: () => catalog,
-  create: () => create
+var exports_tool2 = {};
+__export(exports_tool2, {
+  CodeModeTool: () => exports_tool2,
+  catalog: () => catalog2,
+  create: () => create2
 });
 import { CodeMode, Namespace, Tool, toolError } from "@opencode-ai/codemode";
 import { Effect, Ref, Schema, Semaphore } from "effect";
@@ -40,7 +40,7 @@ var description = [
   "Await every call whose completion matters; pending calls are interrupted when execution ends. Run independent calls concurrently with `Promise.all`."
 ].join(`
 `);
-var create = (inventory, executeTool) => {
+var create2 = (inventory, executeTool) => {
   return {
     name: "execute",
     description,
@@ -51,17 +51,17 @@ var create = (inventory, executeTool) => {
       const files = yield* Ref.make([]);
       const calls = yield* Ref.make([]);
       const lock = Semaphore.makeUnsafe(1);
-      const updateCalls = (update) => lock.withPermit(Ref.updateAndGet(calls, update).pipe(Effect.flatMap((toolCalls2) => context.progress({ toolCalls: toolCalls2 }))));
+      const updateCalls = (update) => lock.withPermit(Ref.updateAndGet(calls, update).pipe(Effect.flatMap((toolCalls) => context.progress({ toolCalls }))));
       const result = yield* runtime(inventory, (name, tool, input) => Effect.gen(function* () {
-        const index = yield* Ref.getAndUpdate(callIndex, (index2) => index2 + 1);
+        const index = yield* Ref.getAndUpdate(callIndex, (index) => index + 1);
         const executed = yield* executeTool(name, tool, input, context);
-        const content2 = typeof executed.content === "string" ? [{ type: "text", text: executed.content }] : executed.content ?? [];
-        const outputFileParts = outputFiles(content2);
+        const content = typeof executed.content === "string" ? [{ type: "text", text: executed.content }] : executed.content ?? [];
+        const outputFileParts = outputFiles(content);
         if (outputFileParts.length > 0)
           yield* Ref.update(files, (items) => [...items, { index, files: outputFileParts }]);
         if (executed.output !== undefined)
           return executed.output;
-        const text = content2.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+        const text = content.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
 `);
         return text === "" ? null : text;
       }), {
@@ -115,7 +115,7 @@ var create = (inventory, executeTool) => {
     })
   };
 };
-var catalog = (inventory) => {
+var catalog2 = (inventory) => {
   const pinned = new Set(Array.from(inventory.tools.values()).filter((registration) => registration.options?.pinned === true).map(qualifiedName));
   const root = { children: new Map };
   for (const namespace of inventory.namespaces?.values() ?? [])
@@ -153,7 +153,7 @@ function runtime(inventory, executeTool, hooks) {
   for (const namespace of inventory.namespaces?.values() ?? [])
     getNode(root, namespace.name).namespace = namespace;
   for (const [name, registration] of inventory.tools) {
-    const child = definition(registration);
+    const child = definition2(registration);
     getNode(root, qualifiedName(registration)).tool = Tool.make({
       description: child.description,
       input: child.inputSchema,
@@ -211,7 +211,7 @@ function flattenTools(node, path, tools) {
     flattenTools(child, [...path, name], tools);
 }
 function qualifiedName(registration) {
-  const normalized = normalizedName(registration);
+  const normalized = normalizedName2(registration);
   if (registration.options?.namespace === undefined)
     return normalized;
   return `${registration.options.namespace}.${normalized}`;
@@ -260,4 +260,4 @@ function outputFiles(content) {
   });
 }
 
-export { create, catalog, exports_tool };
+export { create2, catalog2, exports_tool2 };

package/dist/chunks/{schema-xdb88cdw.js → pty-711hfp6y.js}

@@ -1,19 +1,19 @@
 import {
-  PositiveInt
-} from "./schema-j07kk359.js";
+  PositiveInt2
+} from "./pty-p8qxwesx.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/v1/config/server.ts
 var exports_server = {};
 __export(exports_server, {
   ConfigServerV1: () => exports_server,
-  Server: () => Server
+  Server: () => Server2
 });
 import { Schema } from "effect";
-var Server = Schema.Struct({
-  port: Schema.optional(PositiveInt).annotate({
+var Server2 = Schema.Struct({
+  port: Schema.optional(PositiveInt2).annotate({
     description: "Port to listen on"
   }),
   hostname: Schema.optional(Schema.String).annotate({ description: "Hostname to listen on" }),
@@ -26,4 +26,4 @@ var Server = Schema.Struct({
   })
 }).annotate({ identifier: "ServerConfig" });
 
-export { Server, exports_server };
+export { Server2, exports_server };

package/dist/chunks/{schema-6bwmg5am.js → pty-71c4ctfp.js}

@@ -1,100 +1,101 @@
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  Service79,
+  node84
+} from "./pty-y974v3mv.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/form.ts
 var exports_form = {};
 __export(exports_form, {
-  AlreadyExistsError: () => AlreadyExistsError,
-  AlreadySettledError: () => AlreadySettledError,
-  Answer: () => Answer,
-  Event: () => Event,
-  Field: () => Field,
-  Fields: () => Fields,
+  AlreadyExistsError: () => AlreadyExistsError2,
+  AlreadySettledError: () => AlreadySettledError2,
+  Answer: () => Answer2,
+  Event: () => Event10,
+  Field: () => Field2,
+  Fields: () => Fields2,
   Form: () => exports_form,
-  ID: () => ID,
-  Info: () => Info,
-  InvalidAnswerError: () => InvalidAnswerError,
-  InvalidFormError: () => InvalidFormError,
-  NotFoundError: () => NotFoundError,
-  Reply: () => Reply,
-  Service: () => Service,
-  State: () => State,
-  When: () => When,
-  layer: () => layer,
-  node: () => node,
-  validateAnswer: () => validateAnswer,
-  validateFields: () => validateFields
+  ID: () => ID6,
+  Info: () => Info7,
+  InvalidAnswerError: () => InvalidAnswerError2,
+  InvalidFormError: () => InvalidFormError2,
+  NotFoundError: () => NotFoundError4,
+  Reply: () => Reply2,
+  Service: () => Service50,
+  State: () => State3,
+  When: () => When2,
+  layer: () => layer22,
+  node: () => node54,
+  validateAnswer: () => validateAnswer2,
+  validateFields: () => validateFields2
 });
 import { Form } from "@opencode-ai/schema/form";
 import { Cache, Context, Deferred, Duration, Effect, Exit, Layer, Option, Schema } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
-import { Event } from "@opencode-ai/schema/form";
+import { Event as Event10 } from "@opencode-ai/schema/form";
 var RETENTION = Duration.minutes(10);
-var ID = Form.ID;
-var Info = Form.Info;
-var Field = Form.Field;
-var Fields = Form.Fields;
-var When = Form.When;
-var State = Form.State;
-var Answer = Form.Answer;
-var Reply = Form.Reply;
+var ID6 = Form.ID;
+var Info7 = Form.Info;
+var Field2 = Form.Field;
+var Fields2 = Form.Fields;
+var When2 = Form.When;
+var State3 = Form.State;
+var Answer2 = Form.Answer;
+var Reply2 = Form.Reply;
 
-class NotFoundError extends Schema.TaggedError()("Form.NotFoundError", {
-  id: ID
+class NotFoundError4 extends Schema.TaggedError()("Form.NotFoundError", {
+  id: ID6
 }) {
   get message() {
     return `Form not found: ${this.id}`;
   }
 }
 
-class AlreadySettledError extends Schema.TaggedError()("Form.AlreadySettledError", {
-  id: ID
+class AlreadySettledError2 extends Schema.TaggedError()("Form.AlreadySettledError", {
+  id: ID6
 }) {
   get message() {
     return `Form already settled: ${this.id}`;
   }
 }
 
-class AlreadyExistsError extends Schema.TaggedError()("Form.AlreadyExistsError", {
-  id: ID
+class AlreadyExistsError2 extends Schema.TaggedError()("Form.AlreadyExistsError", {
+  id: ID6
 }) {
   get message() {
     return `Form already exists: ${this.id}`;
   }
 }
 
-class InvalidAnswerError extends Schema.TaggedError()("Form.InvalidAnswerError", {
-  id: ID,
+class InvalidAnswerError2 extends Schema.TaggedError()("Form.InvalidAnswerError", {
+  id: ID6,
   message: Schema.String
 }) {
 }
 
-class InvalidFormError extends Schema.TaggedError()("Form.InvalidFormError", {
+class InvalidFormError2 extends Schema.TaggedError()("Form.InvalidFormError", {
   message: Schema.String
 }) {
 }
 
-class Service extends Context.Service()("@opencode/Form") {
+class Service50 extends Context.Service()("@opencode/Form") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const bus = yield* exports_bus.Service;
+var layer22 = Layer.effect(Service50, Effect.gen(function* () {
+  const bus = yield* Service79;
   const forms = yield* Cache.makeWith(() => Effect.die(new Error("Form cache must be used via set/getSuccess, never get")), {
     capacity: Number.MAX_SAFE_INTEGER,
     timeToLive: (exit) => Exit.isSuccess(exit) && exit.value.state.status === "pending" ? Duration.infinity : RETENTION
   });
-  const requireEntry = Effect.fn("Form.requireEntry")((id) => Cache.getSuccess(forms, id).pipe(Effect.flatMap((entry) => Effect.fromOption(entry, () => new NotFoundError({ id })))));
+  const requireEntry = Effect.fn("Form.requireEntry")((id) => Cache.getSuccess(forms, id).pipe(Effect.flatMap((entry) => Effect.fromOption(entry, () => new NotFoundError4({ id })))));
   const create = Effect.fn("Form.create")((input) => Effect.uninterruptible(Effect.gen(function* () {
-    const id = input.id ?? ID.create();
+    const id = input.id ?? ID6.create();
     const existing = yield* Cache.getSuccess(forms, id);
     if (Option.isSome(existing))
-      return yield* new AlreadyExistsError({ id });
-    const invalid = validateFields(input.fields);
+      return yield* new AlreadyExistsError2({ id });
+    const invalid = validateFields2(input.fields);
     if (invalid)
-      return yield* new InvalidFormError({ message: invalid });
+      return yield* new InvalidFormError2({ message: invalid });
     const form = {
       id,
       sessionID: input.sessionID,
@@ -129,10 +130,10 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   const reply = Effect.fn("Form.reply")((input) => Effect.uninterruptible(Effect.gen(function* () {
     const entry = yield* requireEntry(input.id);
     if (entry.state.status !== "pending")
-      return yield* new AlreadySettledError({ id: input.id });
-    const invalid = validateAnswer(entry.form.fields, input.answer);
+      return yield* new AlreadySettledError2({ id: input.id });
+    const invalid = validateAnswer2(entry.form.fields, input.answer);
     if (invalid)
-      return yield* new InvalidAnswerError({ id: input.id, message: invalid });
+      return yield* new InvalidAnswerError2({ id: input.id, message: invalid });
     const next = { status: "answered", answer: input.answer };
     yield* bus.publish(Form.Event.Replied, {
       id: input.id,
@@ -145,17 +146,17 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   const cancel = Effect.fn("Form.cancel")((id) => Effect.uninterruptible(Effect.gen(function* () {
     const entry = yield* requireEntry(id);
     if (entry.state.status !== "pending")
-      return yield* new AlreadySettledError({ id });
+      return yield* new AlreadySettledError2({ id });
     const next = { status: "cancelled" };
     yield* bus.publish(Form.Event.Cancelled, { id, sessionID: entry.form.sessionID });
     yield* Cache.set(forms, id, { ...entry, state: next });
     yield* Deferred.succeed(entry.deferred, next);
   })));
   yield* Effect.addFinalizer(() => Cache.values(forms).pipe(Effect.flatMap((entries) => Effect.forEach(Array.from(entries).filter((entry) => entry.state.status === "pending"), (entry) => cancel(entry.form.id).pipe(Effect.ignore), { discard: true }))));
-  return Service.of({ create, ask, get, list, state, reply, cancel });
+  return Service50.of({ create, ask, get, list, state, reply, cancel });
 }));
-var node = makeLocationNode({ service: Service, layer, deps: [exports_bus.node] });
-function validateAnswer(form, answer) {
+var node54 = makeLocationNode({ service: Service50, layer: layer22, deps: [node84] });
+function validateAnswer2(form, answer) {
   const fields = new Map(form.map((field) => [field.key, field]));
   for (const key of Object.keys(answer)) {
     if (!fields.has(key))
@@ -192,7 +193,7 @@ function matches(when, value) {
   const hit = Array.isArray(value) ? value.some((item) => item === when.value) : value === when.value;
   return when.op === "eq" ? hit : !hit;
 }
-function validateFields(fields) {
+function validateFields2(fields) {
   if (fields.length === 0)
     return "Form must have at least one field";
   const earlier = new Map;
@@ -306,4 +307,4 @@ function isDateTime(value) {
   return !Number.isNaN(new Date(value).getTime());
 }
 
-export { ID, Info, Field, Fields, When, State, Answer, Reply, NotFoundError, AlreadySettledError, AlreadyExistsError, InvalidAnswerError, InvalidFormError, Service, layer, node, validateAnswer, validateFields, exports_form, Event };
+export { ID6, Info7, Field2, Fields2, When2, State3, Answer2, Reply2, NotFoundError4, AlreadySettledError2, AlreadyExistsError2, InvalidAnswerError2, InvalidFormError2, Service50, layer22, node54, validateAnswer2, validateFields2, exports_form, Event10 };

package/dist/chunks/{schema-qf52r0wh.js → pty-759pz1a2.js}

@@ -1,32 +1,32 @@
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/plugin/instance.ts
-var exports_instance = {};
-__export(exports_instance, {
-  InstancePlugins: () => exports_instance,
-  Service: () => Service,
-  bound: () => bound,
-  node: () => node
+var exports_instance2 = {};
+__export(exports_instance2, {
+  InstancePlugins: () => exports_instance2,
+  Service: () => Service5,
+  bound: () => bound2,
+  node: () => node7
 });
 import { Context, Layer } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 
-class Service extends Context.Service()("@opencode/InstancePlugins") {
+class Service5 extends Context.Service()("@opencode/InstancePlugins") {
 }
-var node = makeLocationNode({
-  service: Service,
-  layer: bound([]),
+var node7 = makeLocationNode({
+  service: Service5,
+  layer: bound2([]),
   deps: []
 });
-function bound(plugins) {
+function bound2(plugins) {
   const duplicates = plugins.filter((plugin, index) => plugins.findIndex((other) => other.id === plugin.id) !== index);
   if (duplicates.length > 0) {
     throw new Error(`duplicate instance plugin ids: ${duplicates.map((plugin) => plugin.id).join(", ")}`);
   }
   const stamped = plugins.map((plugin) => ({ ...plugin, revision: "instance", source: { type: "sdk" } }));
-  return Layer.succeed(Service, Service.of({ all: () => stamped }));
+  return Layer.succeed(Service5, Service5.of({ all: () => stamped }));
 }
 
-export { Service, node, bound, exports_instance };
+export { Service5, node7, bound2, exports_instance2 };

package/dist/chunks/{schema-57j2wsfm.js → pty-76ma23qb.js}

@@ -1,48 +1,50 @@
 import {
-  exports_skill_file
-} from "./schema-2c5k0n78.js";
+  Service63
+} from "./pty-fn68vvm1.js";
 import {
-  exports_discovery
-} from "./schema-6hppa3xw.js";
+  AbsolutePath2
+} from "./pty-p8qxwesx.js";
 import {
-  exports_skill
-} from "./schema-tbzs2pmr.js";
+  Service72
+} from "./pty-5aq0nxp3.js";
 import {
-  exports_config
-} from "./schema-jq0ga1pd.js";
+  Service62
+} from "./pty-amgxn0m4.js";
 import {
-  exports_watcher
-} from "./schema-v9qxqszp.js";
+  DirectorySource2,
+  UrlSource2,
+  Source3
+} from "./pty-5b9mh310.js";
 import {
-  exports_location
-} from "./schema-9kt3hna5.js";
+  Service12
+} from "./pty-4x0nmcjx.js";
 import {
-  AbsolutePath
-} from "./schema-j07kk359.js";
+  parse2
+} from "./pty-baqx186v.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/config/plugin/skill.ts
-var exports_skill2 = {};
-__export(exports_skill2, {
-  ConfigSkillPlugin: () => exports_skill2,
-  Plugin: () => Plugin
+var exports_skill3 = {};
+__export(exports_skill3, {
+  ConfigSkillPlugin: () => exports_skill3,
+  Plugin: () => Plugin42
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { FSUtil } from "@opencode-ai/util/fs-util";
 import { Global } from "@opencode-ai/util/global";
 import path from "path";
 import { Effect, FiberMap, PubSub, Semaphore, Stream } from "effect";
-var Plugin = define({
+var Plugin42 = define({
   id: "opencode.config.skill",
   effect: Effect.fn(function* (ctx) {
-    const config = yield* exports_config.Service;
-    const discovery = yield* exports_discovery.Service;
+    const config = yield* Service62;
+    const discovery = yield* Service12;
     const fs = yield* FSUtil.Service;
     const global = yield* Global.Service;
-    const location = yield* exports_location.Service;
-    const watcher = yield* exports_watcher.Service;
+    const location = yield* Service72;
+    const watcher = yield* Service63;
     const loaded = {
       entries: yield* config.entries(),
       skills: []
@@ -52,8 +54,8 @@ var Plugin = define({
     const lock = Semaphore.makeUnsafe(1);
     const watch = Effect.fn("ConfigSkillPlugin.watch")(function* (directory, type) {
       const target = path.resolve(directory);
-      const updates2 = yield* watcher.subscribe({ path: target, type });
-      yield* FiberMap.run(watches, `${type}:${target}`, updates2.pipe(Stream.runForEach((update) => PubSub.publish(changes, update.path).pipe(Effect.asVoid))), { onlyIfMissing: true, startImmediately: true });
+      const updates = yield* watcher.subscribe({ path: target, type });
+      yield* FiberMap.run(watches, `${type}:${target}`, updates.pipe(Stream.runForEach((update) => PubSub.publish(changes, update.path).pipe(Effect.asVoid))), { onlyIfMissing: true, startImmediately: true });
     });
     function firstMissing(target) {
       const parent = path.dirname(target);
@@ -85,7 +87,7 @@ var Plugin = define({
     const sources = () => {
       const result = [];
       const add = (source) => {
-        if (result.some((item) => exports_skill.Source.equals(item, source)))
+        if (result.some((item) => Source3.equals(item, source)))
           return;
         result.push(source);
       };
@@ -94,28 +96,28 @@ var Plugin = define({
       const directories = loaded.entries.flatMap((entry) => entry.type === "directory" ? [entry.path] : []);
       const items = loaded.entries.flatMap((entry) => entry.type === "document" ? entry.info.skills ?? [] : []);
       for (const directory of [...claude, ...agents]) {
-        add(exports_skill.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skills")) }));
+        add(DirectorySource2.make({ type: "directory", path: AbsolutePath2.make(path.join(directory, "skills")) }));
       }
       for (const directory of directories) {
-        add(exports_skill.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skill")) }));
-        add(exports_skill.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skills")) }));
+        add(DirectorySource2.make({ type: "directory", path: AbsolutePath2.make(path.join(directory, "skill")) }));
+        add(DirectorySource2.make({ type: "directory", path: AbsolutePath2.make(path.join(directory, "skills")) }));
       }
       for (const item of items) {
         if (URL.canParse(item) && /^(https?:)$/.test(new URL(item).protocol)) {
-          add(exports_skill.UrlSource.make({ type: "url", url: item }));
+          add(UrlSource2.make({ type: "url", url: item }));
           continue;
         }
         const expanded = item.startsWith("~/") ? path.join(global.home, item.slice(2)) : item;
-        add(exports_skill.DirectorySource.make({
+        add(DirectorySource2.make({
           type: "directory",
-          path: AbsolutePath.make(path.isAbsolute(expanded) ? expanded : path.join(location.directory, expanded))
+          path: AbsolutePath2.make(path.isAbsolute(expanded) ? expanded : path.join(location.directory, expanded))
         }));
       }
       return result;
     };
     const load = Effect.fn("ConfigSkillPlugin.load")(function* (source) {
       const directories = source.type === "directory" ? [source.path] : yield* discovery.pull(source.url).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to load skill source", {
-        source: exports_skill.Source.key(source),
+        source: Source3.key(source),
         cause
       }).pipe(Effect.as([]))));
       const roots = (yield* Effect.forEach(directories, watchDirectory)).flat();
@@ -131,7 +133,7 @@ var Plugin = define({
           }));
           if (!content)
             continue;
-          const parsed = exports_skill_file.parse(directory, filepath, content);
+          const parsed = parse2(directory, filepath, content);
           if (parsed._tag === "Skipped") {
             yield* Effect.logDebug("skill file skipped", {
               filepath,
@@ -144,7 +146,7 @@ var Plugin = define({
         }
       }
       yield* Effect.logDebug("skill source loaded", {
-        source: exports_skill.Source.key(source),
+        source: Source3.key(source),
         type: source.type,
         directories,
         skills: skills.map((skill) => skill.id)
@@ -163,7 +165,7 @@ var Plugin = define({
       if (file) {
         yield* Effect.logInfo("skills rescanned", {
           file,
-          sources: current.map(exports_skill.Source.key),
+          sources: current.map(Source3.key),
           skills: loaded.skills.map((skill) => skill.id)
         });
       }
@@ -179,4 +181,4 @@ var Plugin = define({
   })
 });
 
-export { Plugin, exports_skill2 as exports_skill };
+export { Plugin42, exports_skill3 };

package/dist/chunks/{schema-hgr9y616.js → pty-7bmhse3q.js}

@@ -1,8 +1,8 @@
 import {
-  getTableColumnsRuntime,
-  mapUpdateSet,
-  orderSelectedFields
-} from "./schema-k8b45nas.js";
+  getTableColumnsRuntime2,
+  orderSelectedFields2,
+  mapUpdateSet2
+} from "./pty-emrn6kk6.js";
 
 // src/database/drizzle/sqlite-core/effect/insert.ts
 import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
@@ -11,7 +11,7 @@ import { SQL, sql } from "drizzle-orm/sql/sql";
 import { extractUsedTable } from "drizzle-orm/sqlite-core/utils";
 import { haveSameKeys } from "drizzle-orm/utils";
 import { QueryBuilder } from "drizzle-orm/sqlite-core/query-builders/query-builder";
-class SQLiteEffectInsertBuilder {
+class SQLiteEffectInsertBuilder2 {
   table;
   session;
   dialect;
@@ -28,18 +28,18 @@ class SQLiteEffectInsertBuilder {
     if (values.length === 0) {
       throw new Error("values() must be called with at least one value");
     }
-    return new SQLiteEffectInsertBase(this.table, values, this.session, this.dialect, this.withList);
+    return new SQLiteEffectInsertBase2(this.table, values, this.session, this.dialect, this.withList);
   }
   select(selectQuery) {
     const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder) : selectQuery;
-    if (!is(select, SQL) && !haveSameKeys(getTableColumnsRuntime(this.table), select._.selectedFields)) {
+    if (!is(select, SQL) && !haveSameKeys(getTableColumnsRuntime2(this.table), select._.selectedFields)) {
       throw new Error("Insert select error: selected fields are not the same or are in a different order compared to the table definition");
     }
-    return new SQLiteEffectInsertBase(this.table, select, this.session, this.dialect, this.withList, true);
+    return new SQLiteEffectInsertBase2(this.table, select, this.session, this.dialect, this.withList, true);
   }
 }
 
-class SQLiteEffectInsertBase {
+class SQLiteEffectInsertBase2 {
   effectSession;
   effectDialect;
   static [entityKind] = "SQLiteEffectInsert";
@@ -49,8 +49,8 @@ class SQLiteEffectInsertBase {
     this.effectDialect = effectDialect;
     this.config = { table, values, withList, select };
   }
-  returning(fields = getTableColumnsRuntime(this.config.table)) {
-    this.config.returning = orderSelectedFields(fields);
+  returning(fields = getTableColumnsRuntime2(this.config.table)) {
+    this.config.returning = orderSelectedFields2(fields);
     return this;
   }
   onConflictDoNothing(config = {}) {
@@ -75,7 +75,7 @@ class SQLiteEffectInsertBase {
     const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : undefined;
     const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : undefined;
     const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
-    const setSql = this.effectDialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
+    const setSql = this.effectDialect.buildUpdateSet(this.config.table, mapUpdateSet2(this.config.table, config.set));
     this.config.onConflict.push(sql` on conflict ${targetSql}${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`);
     return this;
   }
@@ -113,6 +113,6 @@ class SQLiteEffectInsertBase {
     return this;
   }
 }
-applyEffectWrapper(SQLiteEffectInsertBase);
+applyEffectWrapper(SQLiteEffectInsertBase2);
 
-export { SQLiteEffectInsertBuilder, SQLiteEffectInsertBase };
+export { SQLiteEffectInsertBuilder2, SQLiteEffectInsertBase2 };

package/dist/chunks/pty-7dqw4kz8.js

@@ -0,0 +1,16 @@
+import {
+  __export
+} from "./pty-9rqn6x4v.js";
+
+// src/v1/config/plugin.ts
+var exports_plugin3 = {};
+__export(exports_plugin3, {
+  ConfigPluginV1: () => exports_plugin3,
+  Options: () => Options9,
+  Spec: () => Spec2
+});
+import { Schema } from "effect";
+var Options9 = Schema.Record(Schema.String, Schema.Unknown);
+var Spec2 = Schema.Union([Schema.String, Schema.mutable(Schema.Tuple([Schema.String, Options9]))]);
+
+export { Options9, Spec2, exports_plugin3 };