@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-ecxv0vtt.js

@@ -0,0 +1,258 @@
+// src/database/schema.gen.ts
+import { Effect } from "effect";
+var schema = {
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`account_state\` (
+          \`id\` integer PRIMARY KEY,
+          \`active_account_id\` text,
+          \`active_org_id\` text,
+          CONSTRAINT \`fk_account_state_active_account_id_account_id_fk\` FOREIGN KEY (\`active_account_id\`) REFERENCES \`account\`(\`id\`) ON DELETE SET NULL
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`account\` (
+          \`id\` text PRIMARY KEY,
+          \`email\` text NOT NULL,
+          \`url\` text NOT NULL,
+          \`access_token\` text NOT NULL,
+          \`refresh_token\` text NOT NULL,
+          \`token_expiry\` integer,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`control_account\` (
+          \`email\` text NOT NULL,
+          \`url\` text NOT NULL,
+          \`access_token\` text NOT NULL,
+          \`refresh_token\` text NOT NULL,
+          \`token_expiry\` integer,
+          \`active\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          CONSTRAINT \`control_account_pk\` PRIMARY KEY(\`email\`, \`url\`)
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`credential\` (
+          \`id\` text PRIMARY KEY,
+          \`integration_id\` text,
+          \`label\` text NOT NULL,
+          \`value\` text NOT NULL,
+          \`connector_id\` text,
+          \`method_id\` text,
+          \`active\` integer,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`event_sequence\` (
+          \`aggregate_id\` text PRIMARY KEY,
+          \`seq\` integer NOT NULL,
+          \`owner_id\` text
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`event\` (
+          \`id\` text PRIMARY KEY,
+          \`aggregate_id\` text NOT NULL,
+          \`seq\` integer NOT NULL,
+          \`created\` integer DEFAULT 0 NOT NULL,
+          \`type\` text NOT NULL,
+          \`data\` text NOT NULL,
+          CONSTRAINT \`fk_event_aggregate_id_event_sequence_aggregate_id_fk\` FOREIGN KEY (\`aggregate_id\`) REFERENCES \`event_sequence\`(\`aggregate_id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`kv\` (
+          \`key\` text PRIMARY KEY,
+          \`value\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`permission\` (
+          \`id\` text PRIMARY KEY,
+          \`project_id\` text NOT NULL,
+          \`action\` text NOT NULL,
+          \`resource\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          CONSTRAINT \`fk_permission_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`project_directory\` (
+          \`project_id\` text NOT NULL,
+          \`directory\` text NOT NULL,
+          \`type\` text,
+          \`strategy\` text,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`project_directory_pk\` PRIMARY KEY(\`project_id\`, \`directory\`),
+          CONSTRAINT \`fk_project_directory_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`project\` (
+          \`id\` text PRIMARY KEY,
+          \`worktree\` text NOT NULL,
+          \`vcs\` text,
+          \`name\` text,
+          \`icon_url\` text,
+          \`icon_url_override\` text,
+          \`icon_color\` text,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`time_initialized\` integer,
+          \`sandboxes\` text NOT NULL,
+          \`commands\` text
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`instruction_blob\` (
+          \`hash\` text PRIMARY KEY,
+          \`value\` text
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`instruction_entry\` (
+          \`session_id\` text NOT NULL,
+          \`key\` text NOT NULL,
+          \`value\` text,
+          \`removed\` integer DEFAULT false NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          CONSTRAINT \`instruction_entry_pk\` PRIMARY KEY(\`session_id\`, \`key\`),
+          CONSTRAINT \`fk_instruction_entry_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`instruction_state\` (
+          \`session_id\` text PRIMARY KEY,
+          \`epoch_start\` integer NOT NULL,
+          \`through_seq\` integer NOT NULL,
+          \`initial_values\` text NOT NULL,
+          \`current_values\` text NOT NULL,
+          CONSTRAINT \`fk_instruction_state_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`session_inbox\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`payload\` text NOT NULL,
+          \`delivery\` text NOT NULL,
+          \`enqueued_seq\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`fk_session_inbox_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`session_message\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`seq\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`data\` text NOT NULL,
+          CONSTRAINT \`fk_session_message_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`session_pending\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`data\` text NOT NULL,
+          \`delivery\` text,
+          \`admitted_seq\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`fk_session_pending_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`session_v2\` (
+          \`id\` text PRIMARY KEY,
+          \`project_id\` text NOT NULL,
+          \`workspace_id\` text,
+          \`parent_id\` text,
+          \`fork_session_id\` text,
+          \`fork_boundary\` text,
+          \`slug\` text NOT NULL,
+          \`directory\` text NOT NULL,
+          \`path\` text,
+          \`title\` text,
+          \`version\` text NOT NULL,
+          \`share_url\` text,
+          \`summary_additions\` integer,
+          \`summary_deletions\` integer,
+          \`summary_files\` integer,
+          \`summary_diffs\` text,
+          \`metadata\` text,
+          \`cost\` real DEFAULT 0 NOT NULL,
+          \`tokens_input\` integer DEFAULT 0 NOT NULL,
+          \`tokens_output\` integer DEFAULT 0 NOT NULL,
+          \`tokens_reasoning\` integer DEFAULT 0 NOT NULL,
+          \`tokens_cache_read\` integer DEFAULT 0 NOT NULL,
+          \`tokens_cache_write\` integer DEFAULT 0 NOT NULL,
+          \`revert\` text,
+          \`permission\` text,
+          \`agent\` text,
+          \`model\` text,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`time_compacting\` integer,
+          \`time_archived\` integer,
+          \`time_suspended\` integer,
+          \`resume_attempts\` integer DEFAULT 0 NOT NULL,
+          CONSTRAINT \`fk_session_v2_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`workspace\` (
+          \`id\` text PRIMARY KEY,
+          \`provider\` text NOT NULL,
+          \`binding\` text NOT NULL,
+          \`created_at\` integer NOT NULL,
+          \`last_used_at\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`worktree\` (
+          \`project_id\` text NOT NULL,
+          \`directory\` text NOT NULL,
+          \`strategy\` text,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`worktree_pk\` PRIMARY KEY(\`project_id\`, \`directory\`),
+          CONSTRAINT \`fk_worktree_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`CREATE UNIQUE INDEX \`event_aggregate_seq_idx\` ON \`event\` (\`aggregate_id\`,\`seq\`);`);
+      yield* tx.run(`CREATE INDEX \`event_aggregate_type_seq_idx\` ON \`event\` (\`aggregate_id\`,\`type\`,\`seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`permission_project_action_resource_idx\` ON \`permission\` (\`project_id\`,\`action\`,\`resource\`);`);
+      yield* tx.run(`CREATE INDEX \`session_inbox_session_delivery_seq_idx\` ON \`session_inbox\` (\`session_id\`,\`delivery\`,\`enqueued_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_inbox_session_enqueued_seq_idx\` ON \`session_inbox\` (\`session_id\`,\`enqueued_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_message_session_seq_idx\` ON \`session_message\` (\`session_id\`,\`seq\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_type_seq_idx\` ON \`session_message\` (\`session_id\`,\`type\`,\`seq\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_time_created_id_idx\` ON \`session_message\` (\`session_id\`,\`time_created\`,\`id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_time_created_idx\` ON \`session_message\` (\`time_created\`);`);
+      yield* tx.run(`CREATE INDEX \`session_pending_session_delivery_seq_idx\` ON \`session_pending\` (\`session_id\`,\`delivery\`,\`admitted_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_pending_session_compaction_idx\` ON \`session_pending\` (\`session_id\`) WHERE "session_pending"."type" = 'compaction';`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_pending_session_admitted_seq_idx\` ON \`session_pending\` (\`session_id\`,\`admitted_seq\`);`);
+      yield* tx.run(`CREATE INDEX \`session_v2_project_idx\` ON \`session_v2\` (\`project_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_v2_workspace_idx\` ON \`session_v2\` (\`workspace_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_v2_parent_idx\` ON \`session_v2\` (\`parent_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_v2_time_suspended_idx\` ON \`session_v2\` (\`time_suspended\`) WHERE "session_v2"."time_suspended" is not null;`);
+    });
+  }
+};
+var schema_gen_default = schema;
+
+export { schema_gen_default };

package/dist/chunks/ripgrep-ed4jjjcc.js

@@ -0,0 +1,171 @@
+import {
+  Failed,
+  NotFound,
+  WrongKind
+} from "./ripgrep-zthe9zqc.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/environment/memory.ts
+var exports_memory = {};
+__export(exports_memory, {
+  makeMemoryDriver: () => makeMemoryDriver,
+  EnvironmentMemory: () => exports_memory
+});
+import path from "node:path";
+import { Effect, PlatformError } from "effect";
+import { make } from "effect/unstable/process/ChildProcessSpawner";
+var makeMemoryDriver = () => {
+  const nodes = new Map([["/", { type: "directory", mtimeMs: Date.now() }]]);
+  const key = (value) => path.posix.resolve("/", value);
+  const info = (node) => ({
+    type: node.type,
+    size: node.type === "file" ? node.bytes.length : node.type === "symlink" ? new TextEncoder().encode(node.target).length : 0,
+    mtimeMs: node.mtimeMs
+  });
+  const resolveKey = (value, followFinal, seen = new Set) => {
+    const normalized = key(value);
+    const parts = normalized.split("/").filter(Boolean);
+    const base = "/";
+    const walk = (current, index) => {
+      if (index === parts.length)
+        return current;
+      const part = parts[index];
+      const candidate = path.posix.join(current, part);
+      const node = nodes.get(candidate);
+      if (node?.type !== "symlink" || !followFinal && index === parts.length - 1)
+        return walk(candidate, index + 1);
+      if (seen.has(candidate))
+        return;
+      seen.add(candidate);
+      const target = path.posix.resolve(path.posix.dirname(candidate), node.target);
+      return resolveKey(path.posix.join(target, ...parts.slice(index + 1)), followFinal, seen);
+    };
+    return walk(base, 0);
+  };
+  const lookup = (value) => nodes.get(resolveKey(value, false) ?? key(value));
+  const requireParent = (value) => {
+    const parentPath = path.posix.dirname(key(value));
+    const parent = nodes.get(resolveKey(parentPath, true) ?? parentPath);
+    if (!parent)
+      throw new Error(`Parent directory does not exist: ${path.posix.dirname(value)}`);
+    if (parent.type !== "directory")
+      throw new Error(`Parent is not a directory: ${path.posix.dirname(value)}`);
+  };
+  const mkdirSync = (value) => {
+    const target = resolveKey(value, false) ?? key(value);
+    const existing = nodes.get(target);
+    if (existing?.type === "directory")
+      return;
+    if (existing)
+      throw new Error(`Path is not a directory: ${value}`);
+    const parent = path.posix.dirname(target);
+    if (parent !== target)
+      mkdirSync(parent);
+    nodes.set(target, { type: "directory", mtimeMs: Date.now() });
+  };
+  const failed = (value, cause) => new Failed({ path: value, cause });
+  const overrides = {
+    stat: (value) => {
+      const node = lookup(value);
+      return node ? Effect.succeed(info(node)) : Effect.fail(new NotFound({ path: value }));
+    },
+    read: (value, range) => {
+      const original = lookup(value);
+      if (!original)
+        return Effect.fail(new NotFound({ path: value }));
+      if (original.type === "directory")
+        return Effect.fail(new WrongKind({ path: value, actual: "directory" }));
+      const resolved = resolveKey(value, true);
+      const node = resolved === undefined ? undefined : nodes.get(resolved);
+      if (!node)
+        return Effect.fail(new NotFound({ path: value }));
+      if (node.type !== "file")
+        return Effect.fail(new WrongKind({ path: value, actual: node.type }));
+      const bytes = range === undefined ? node.bytes : node.bytes.subarray(range.offset, range.offset + range.length);
+      return Effect.succeed({ info: info(node), bytes: bytes.slice() });
+    },
+    write: (value, bytes) => Effect.try({
+      try: () => {
+        mkdirSync(path.posix.dirname(key(value)));
+        const existing = lookup(value);
+        if (existing?.type === "directory")
+          throw new Error(`Path is a directory: ${value}`);
+        const target = existing?.type === "symlink" ? resolveKey(value, true) : resolveKey(value, false);
+        if (!target)
+          throw new Error(`Cannot resolve symlink: ${value}`);
+        requireParent(target);
+        nodes.set(target, { type: "file", bytes: bytes.slice(), mtimeMs: Date.now() });
+      },
+      catch: (cause) => failed(value, cause)
+    }),
+    list: (value) => {
+      const target = resolveKey(value, true) ?? key(value);
+      const node = nodes.get(target);
+      if (!node)
+        return Effect.fail(new NotFound({ path: value }));
+      if (node.type !== "directory")
+        return Effect.fail(new WrongKind({ path: value, actual: node.type }));
+      const entries = [...nodes.entries()].filter(([entry]) => entry !== target && path.posix.dirname(entry) === target).map(([entry, child]) => ({ name: path.posix.basename(entry), type: child.type })).sort((a, b) => a.name.localeCompare(b.name));
+      return Effect.succeed(entries);
+    },
+    remove: (value) => Effect.sync(() => {
+      const target = resolveKey(value, false) ?? key(value);
+      for (const entry of nodes.keys()) {
+        if (entry === target || entry.startsWith(`${target}/`))
+          nodes.delete(entry);
+      }
+    }),
+    move: (from, to) => {
+      const source = resolveKey(from, false) ?? key(from);
+      const node = nodes.get(source);
+      if (!node)
+        return Effect.fail(new NotFound({ path: from }));
+      return Effect.try({
+        try: () => {
+          const requested = resolveKey(to, false) ?? key(to);
+          const destination = nodes.get(requested)?.type === "directory" ? path.posix.join(requested, path.posix.basename(source)) : requested;
+          if (node.type === "directory" && destination.startsWith(`${source}/`)) {
+            throw new Error(`Cannot move a directory into itself: ${from}`);
+          }
+          const existing = nodes.get(destination);
+          if (node.type === "directory" && existing && existing.type !== "directory") {
+            throw new Error(`Cannot overwrite a non-directory with a directory: ${to}`);
+          }
+          requireParent(destination);
+          const moved = [...nodes.entries()].filter(([entry]) => entry === source || entry.startsWith(`${source}/`));
+          for (const [entry] of moved)
+            nodes.delete(entry);
+          for (const [entry, child] of moved)
+            nodes.set(`${destination}${entry.slice(source.length)}`, child);
+        },
+        catch: (cause) => failed(from, cause)
+      });
+    },
+    mkdir: (value) => Effect.try({ try: () => mkdirSync(value), catch: (cause) => failed(value, cause) })
+  };
+  const spawner = make((command) => Effect.suspend(() => {
+    const description = command._tag === "StandardCommand" ? command.command : "pipeline";
+    return Effect.fail(PlatformError.systemError({
+      _tag: "Unknown",
+      module: "EnvironmentMemory",
+      method: "spawn",
+      pathOrDescriptor: description,
+      cause: failed(description, new Error("The memory driver cannot spawn processes"))
+    }));
+  }));
+  return {
+    spawner,
+    overrides,
+    symlink: (target, value) => Effect.try({
+      try: () => {
+        requireParent(value);
+        nodes.set(resolveKey(value, false) ?? key(value), { type: "symlink", target, mtimeMs: Date.now() });
+      },
+      catch: (cause) => failed(value, cause)
+    })
+  };
+};
+
+export { makeMemoryDriver, exports_memory };

package/dist/chunks/ripgrep-ehj9csmv.js

@@ -0,0 +1,6 @@
+// src/util/iife.ts
+function iife(fn) {
+  return fn();
+}
+
+export { iife };

package/dist/chunks/ripgrep-em6xpscd.js

@@ -0,0 +1,35 @@
+// src/database/migration/20260812213948_worktree.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260812213948_worktree",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`worktree\` (
+          \`project_id\` text NOT NULL,
+          \`directory\` text NOT NULL,
+          \`strategy\` text,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`worktree_pk\` PRIMARY KEY(\`project_id\`, \`directory\`),
+          CONSTRAINT \`fk_worktree_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        INSERT INTO \`worktree\` (\`project_id\`, \`directory\`, \`strategy\`, \`time_created\`)
+        SELECT
+          \`project_id\`,
+          \`directory\`,
+          CASE
+            WHEN \`strategy\` = 'git_worktree' THEN 'git'
+            WHEN \`strategy\` IS NOT NULL THEN \`strategy\`
+            WHEN \`type\` = 'git_worktree' THEN 'git'
+          END,
+          \`time_created\`
+        FROM \`project_directory\`;
+      `);
+    });
+  }
+};
+var _20260812213948_worktree_default = migration;
+
+export { _20260812213948_worktree_default };

package/dist/chunks/ripgrep-emmqknsm.js

@@ -0,0 +1,26 @@
+// src/database/migration/20260812181746_session_inbox.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260812181746_session_inbox",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`session_inbox\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`payload\` text NOT NULL,
+          \`delivery\` text NOT NULL,
+          \`enqueued_seq\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`fk_session_inbox_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`CREATE INDEX \`session_inbox_session_delivery_seq_idx\` ON \`session_inbox\` (\`session_id\`,\`delivery\`,\`enqueued_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_inbox_session_enqueued_seq_idx\` ON \`session_inbox\` (\`session_id\`,\`enqueued_seq\`);`);
+    });
+  }
+};
+var _20260812181746_session_inbox_default = migration;
+
+export { _20260812181746_session_inbox_default };

package/dist/chunks/ripgrep-erj4j75s.js

@@ -0,0 +1,129 @@
+import {
+  getTableColumnsRuntime,
+  mapUpdateSet,
+  orderSelectedFields
+} from "./ripgrep-ma07p6tt.js";
+
+// src/database/drizzle/sqlite-core/effect/insert.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind, is } from "drizzle-orm/entity";
+import { Param, 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 {
+  table;
+  session;
+  dialect;
+  withList;
+  static [entityKind] = "SQLiteEffectInsertBuilder";
+  constructor(table, session, dialect, withList) {
+    this.table = table;
+    this.session = session;
+    this.dialect = dialect;
+    this.withList = withList;
+  }
+  values(values) {
+    values = Array.isArray(values) ? values : [values];
+    if (values.length === 0) {
+      throw new Error("values() must be called with at least one value");
+    }
+    const mappedValues = values.map((entry) => {
+      const result = {};
+      const cols = getTableColumnsRuntime(this.table);
+      for (const colKey of Object.keys(entry)) {
+        const colValue = entry[colKey];
+        result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
+      }
+      return result;
+    });
+    return new SQLiteEffectInsertBase(this.table, mappedValues, 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)) {
+      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);
+  }
+}
+
+class SQLiteEffectInsertBase {
+  table;
+  effectSession;
+  effectDialect;
+  static [entityKind] = "SQLiteEffectInsert";
+  config;
+  constructor(table, values, effectSession, effectDialect, withList, select) {
+    this.table = table;
+    this.effectSession = effectSession;
+    this.effectDialect = effectDialect;
+    this.config = { table, values, withList, select };
+  }
+  returning(fields = getTableColumnsRuntime(this.config.table)) {
+    this.config.returning = orderSelectedFields(fields);
+    return this;
+  }
+  onConflictDoNothing(config = {}) {
+    if (!this.config.onConflict)
+      this.config.onConflict = [];
+    if (config.target === undefined) {
+      this.config.onConflict.push(sql` on conflict do nothing`);
+      return this;
+    }
+    const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
+    const whereSql = config.where ? sql` where ${config.where}` : sql``;
+    this.config.onConflict.push(sql` on conflict ${targetSql} do nothing${whereSql}`);
+    return this;
+  }
+  onConflictDoUpdate(config) {
+    if (config.where && (config.targetWhere || config.setWhere)) {
+      throw new Error('You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.');
+    }
+    if (!this.config.onConflict)
+      this.config.onConflict = [];
+    const whereSql = config.where ? sql` where ${config.where}` : undefined;
+    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));
+    this.config.onConflict.push(sql` on conflict ${targetSql}${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`);
+    return this;
+  }
+  getSQL() {
+    return this.effectDialect.buildInsertQuery(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: "insert",
+      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(SQLiteEffectInsertBase);
+
+export { SQLiteEffectInsertBuilder, SQLiteEffectInsertBase };

package/dist/chunks/ripgrep-eyk9wdct.js

@@ -0,0 +1,61 @@
+import {
+  InvalidError
+} from "./ripgrep-nr76rjj3.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/config/variable.ts
+var exports_variable = {};
+__export(exports_variable, {
+  substitute: () => substitute,
+  ConfigVariable: () => exports_variable
+});
+import os from "os";
+import path from "path";
+import { Effect } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+var substitute = Effect.fn("ConfigVariable.substitute")(function* (input) {
+  const text = input.text.replace(/\{env:([^}]+)\}/g, (_, varName) => (input.env?.[varName] ?? process.env[varName]) || "");
+  if (!text.includes("{file:"))
+    return text;
+  return yield* substituteFiles(input, text);
+});
+var substituteFiles = Effect.fnUntraced(function* (input, text) {
+  const fs = yield* FSUtil.Service;
+  const configDir = input.type === "path" ? path.dirname(input.path) : input.dir;
+  const configSource = input.type === "path" ? input.path : input.source;
+  const matches = Array.from(text.matchAll(/\{file:[^}]+\}/g));
+  let out = "";
+  let cursor = 0;
+  for (const match of matches) {
+    const token = match[0];
+    const index = match.index;
+    out += text.slice(cursor, index);
+    const lineStart = text.lastIndexOf(`
+`, index - 1) + 1;
+    const prefix = text.slice(lineStart, index).trimStart();
+    if (prefix.startsWith("//")) {
+      out += token;
+      cursor = index + token.length;
+      continue;
+    }
+    const filePath = token.replace(/^\{file:/, "").replace(/\}$/, "");
+    const expandedPath = filePath.startsWith("~/") ? path.join(os.homedir(), filePath.slice(2)) : filePath;
+    const resolvedPath = path.isAbsolute(expandedPath) ? expandedPath : path.resolve(configDir, expandedPath);
+    const fileContent = yield* fs.readFileString(resolvedPath).pipe(Effect.catch((error) => {
+      if (input.missing === "empty")
+        return Effect.succeed("");
+      const message = `bad file reference: "${token}"`;
+      return Effect.fail(new InvalidError({
+        path: configSource,
+        message: error._tag === "PlatformError" && error.reason._tag === "NotFound" ? `${message} ${resolvedPath} does not exist` : message
+      }, { cause: error }));
+    }));
+    out += JSON.stringify(fileContent.trim()).slice(1, -1);
+    cursor = index + token.length;
+  }
+  return out + text.slice(cursor);
+});
+
+export { substitute, exports_variable };