@opencode-ai/core 0.0.0-dev-17471

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

@@ -0,0 +1,294 @@
+import {
+  exports_protected
+} from "./location-mutation-kg1345f7.js";
+import {
+  exports_ripgrep
+} from "./location-mutation-afmh0nd1.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  PositiveInt,
+  RelativePath
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/filesystem/search.ts
+var exports_search = {};
+__export(exports_search, {
+  ripgrepLayer: () => ripgrepLayer,
+  node: () => node2,
+  layer: () => layer,
+  fffLayer: () => fffLayer,
+  configured: () => configured,
+  Service: () => Service2,
+  Options: () => Options,
+  FileSystemSearch: () => exports_search
+});
+import { makeLocationNode as makeLocationNode2 } from "@opencode-ai/util/effect/app-node";
+import path2 from "path";
+import { Clock, Context as Context2, Duration, Effect as Effect2, Layer as Layer2, Schema as Schema2, Scope } from "effect";
+import { Fff } from "#fff";
+import fuzzysort from "fuzzysort";
+
+// src/filesystem.ts
+var exports_filesystem = {};
+__export(exports_filesystem, {
+  node: () => node,
+  Submatch: () => Submatch,
+  Service: () => Service,
+  ReadInput: () => ReadInput,
+  Match: () => Match,
+  ListInput: () => ListInput,
+  GrepInput: () => GrepInput,
+  GlobInput: () => GlobInput,
+  FindInput: () => FindInput,
+  FileSystem: () => exports_filesystem,
+  Event: () => Event,
+  Entry: () => Entry2,
+  DEFAULT_SEARCH_TIMEOUT_MS: () => DEFAULT_SEARCH_TIMEOUT_MS,
+  DEFAULT_SEARCH_LIMIT: () => DEFAULT_SEARCH_LIMIT,
+  Content: () => Content
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import path from "path";
+import { Context, Effect, Layer, Schema } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Entry, FileSystem, FindInput } from "@opencode-ai/schema/filesystem";
+import { Entry as Entry2, Match, Submatch } from "@opencode-ai/schema/filesystem";
+var ReadInput = Schema.Struct({
+  path: RelativePath
+});
+var Content = Schema.Struct({
+  uri: Schema.String,
+  name: Schema.String.pipe(Schema.optional),
+  content: Schema.String,
+  encoding: Schema.Literals(["utf8", "base64"]),
+  mime: Schema.String
+}).annotate({ identifier: "FileSystem.Content" });
+var ListInput = Schema.Struct({
+  path: RelativePath.pipe(Schema.optional)
+});
+var DEFAULT_SEARCH_LIMIT = 100;
+var DEFAULT_SEARCH_TIMEOUT_MS = 30000;
+
+class GlobInput extends Schema.Class("FileSystem.GlobInput")({
+  pattern: Schema.String,
+  path: Schema.optionalKey(RelativePath),
+  limit: Schema.optionalKey(PositiveInt)
+}) {
+}
+
+class GrepInput extends Schema.Class("FileSystem.GrepInput")({
+  pattern: Schema.String,
+  path: Schema.optionalKey(RelativePath),
+  include: Schema.optionalKey(Schema.String),
+  limit: Schema.optionalKey(PositiveInt)
+}) {
+}
+var Event = FileSystem.Event;
+
+class Service extends Context.Service()("@opencode/FileSystem") {
+}
+var baseLayer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const location = yield* exports_location.Service;
+  const search = yield* exports_search.Service;
+  const root = yield* fs.realPath(location.directory).pipe(Effect.orDie);
+  const resolve = Effect.fnUntraced(function* (input) {
+    const absolute = path.resolve(location.directory, input ?? ".");
+    if (!FSUtil.contains(location.directory, absolute))
+      return yield* Effect.die(new Error("Path escapes the location"));
+    const real = yield* fs.realPath(absolute).pipe(Effect.orDie);
+    if (!FSUtil.contains(root, real))
+      return yield* Effect.die(new Error("Path escapes the location"));
+    return { absolute, real, directory: location.directory, root };
+  });
+  return Service.of({
+    find: search.find,
+    read: Effect.fn("FileSystem.read")(function* (input) {
+      const target = yield* resolve(input.path);
+      const info = yield* fs.stat(target.real).pipe(Effect.orDie);
+      if (info.type !== "File")
+        return yield* Effect.die(new Error("Path is not a file"));
+      return {
+        content: yield* fs.readFile(target.real).pipe(Effect.orDie),
+        mime: FSUtil.mimeType(target.real)
+      };
+    }),
+    list: Effect.fn("FileSystem.list")(function* (input = {}) {
+      const target = yield* resolve(input.path);
+      const info = yield* fs.stat(target.real).pipe(Effect.orDie);
+      if (info.type !== "Directory")
+        return yield* Effect.die(new Error("Path is not a directory"));
+      return yield* fs.readDirectoryEntries(target.real).pipe(Effect.orDie, Effect.map((items) => items.flatMap((item) => {
+        if (item.type !== "file" && item.type !== "directory")
+          return [];
+        const absolute = path.join(target.absolute, item.name);
+        const relative = path.relative(target.directory, absolute);
+        return [
+          Entry.make({
+            path: RelativePath.make(relative + (item.type === "directory" ? path.sep : "")),
+            type: item.type
+          })
+        ];
+      }).sort((a, b) => a.type === b.type ? a.path.localeCompare(b.path) : a.type === "directory" ? -1 : 1)));
+    })
+  });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer: baseLayer,
+  deps: [FSUtil.node, exports_location.node, exports_search.node]
+});
+
+// src/filesystem/search.ts
+var Options = Schema2.Struct({
+  fff: Schema2.optional(Schema2.Boolean)
+});
+
+class Service2 extends Context2.Service()("@opencode/FileSystem/Search") {
+}
+var REFRESH_INTERVAL = Duration.toMillis("10 seconds");
+function emptyIndex() {
+  return { files: new Map, directories: new Map };
+}
+function search(index, input) {
+  const items = input.type === "file" ? Array.from(index.files.values()) : input.type === "directory" ? Array.from(index.directories.values()) : [...index.files.values(), ...index.directories.values()];
+  const result = fuzzysort.go(input.query, items, { limit: input.limit ?? 50 });
+  fuzzysort.cleanup();
+  return result.map((item) => {
+    const relative = item.target;
+    const type = relative.endsWith(path2.sep) ? "directory" : "file";
+    return exports_filesystem.Entry.make({
+      path: RelativePath.make(relative),
+      type
+    });
+  });
+}
+var ripgrepLayer = Layer2.effect(Service2, Effect2.gen(function* () {
+  const location = yield* exports_location.Service;
+  const ripgrep = yield* exports_ripgrep.Service;
+  const scope = yield* Scope.Scope;
+  const clock = yield* Clock.Clock;
+  const home = exports_protected.isHome(location.directory);
+  let index = emptyIndex();
+  let initialized = false;
+  let settledAt = Number.NEGATIVE_INFINITY;
+  let refreshing = false;
+  const scan = Effect2.gen(function* () {
+    const next = emptyIndex();
+    const previous = index;
+    if (!initialized)
+      index = next;
+    yield* ripgrep.find({
+      cwd: location.directory,
+      pattern: "*",
+      limit: location.vcs && !home ? Number.MAX_SAFE_INTEGER : 1e5,
+      exclude: home ? [...exports_protected.names()].map((name) => `${name}/**`) : undefined,
+      onEntry: (entry) => Effect2.sync(() => {
+        next.files.set(entry.path, previous.files.get(entry.path) ?? fuzzysort.prepare(entry.path));
+        const parts = entry.path.split("/");
+        parts.slice(0, -1).forEach((_, offset) => {
+          const directory = parts.slice(0, offset + 1).join("/") + path2.sep;
+          if (!next.directories.has(directory))
+            next.directories.set(directory, previous.directories.get(directory) ?? fuzzysort.prepare(directory));
+        });
+      })
+    });
+    index = next;
+    initialized = true;
+  }).pipe(Effect2.orDie, Effect2.ensuring(Effect2.sync(() => {
+    settledAt = clock.currentTimeMillisUnsafe();
+    refreshing = false;
+  })));
+  const refresh = Effect2.sync(() => {
+    if (refreshing || clock.currentTimeMillisUnsafe() < settledAt + REFRESH_INTERVAL)
+      return;
+    refreshing = true;
+    return scan;
+  }).pipe(Effect2.flatMap((effect) => effect ? effect.pipe(Effect2.forkIn(scope)) : Effect2.void));
+  yield* refresh;
+  return Service2.of({
+    find: (input) => Effect2.gen(function* () {
+      yield* refresh;
+      return search(index, input);
+    })
+  });
+}));
+var fffLayer = Layer2.effect(Service2, Effect2.gen(function* () {
+  const location = yield* exports_location.Service;
+  const result = yield* Effect2.try({
+    try: () => Fff.create({
+      basePath: location.directory,
+      aiMode: true,
+      disableMmapCache: true,
+      disableContentIndexing: true
+    }),
+    catch: (cause) => cause
+  }).pipe(Effect2.catch((error) => Effect2.logWarning("failed to initialize fff", { error }).pipe(Effect2.as(undefined))));
+  if (!result?.ok) {
+    if (result)
+      yield* Effect2.logWarning("failed to initialize fff", { error: result.error });
+    return Service2.of({
+      find: () => Effect2.succeed([])
+    });
+  }
+  yield* Effect2.addFinalizer(() => Effect2.sync(() => result.value.destroy()).pipe(Effect2.ignore));
+  return Service2.of({
+    find: (input) => Effect2.sync(() => {
+      const options = { pageIndex: 0, pageSize: input.limit ?? 50 };
+      const items = (() => {
+        if (input.type === "file") {
+          const found2 = result.value.fileSearch(input.query.trim(), options);
+          if (!found2.ok)
+            throw found2.error;
+          return found2.value.items.map((item, index) => ({
+            path: item.relativePath,
+            type: "file",
+            score: found2.value.scores[index]?.total ?? 0
+          }));
+        }
+        if (input.type === "directory") {
+          const found2 = result.value.directorySearch(input.query.trim(), options);
+          if (!found2.ok)
+            throw found2.error;
+          return found2.value.items.map((item, index) => ({
+            path: item.relativePath,
+            type: "directory",
+            score: found2.value.scores[index]?.total ?? 0
+          }));
+        }
+        const found = result.value.mixedSearch(input.query.trim(), options);
+        if (!found.ok)
+          throw found.error;
+        return found.value.items.map((item, index) => ({
+          path: item.item.relativePath,
+          type: item.type,
+          score: found.value.scores[index]?.total ?? 0
+        }));
+      })();
+      return items.sort((a, b) => b.score - a.score || a.path.length - b.path.length).map((item) => {
+        const relative = item.path.replaceAll("\\", "/").replace(/\/$/, "");
+        return exports_filesystem.Entry.make({
+          path: RelativePath.make(relative + (item.type === "directory" ? path2.sep : "")),
+          type: item.type
+        });
+      });
+    })
+  });
+}));
+var layer = (options) => Layer2.unwrap(Effect2.gen(function* () {
+  if (options?.fff === false || options?.fff === undefined && process.platform === "win32" || !Fff.available())
+    return ripgrepLayer;
+  const location = yield* exports_location.Service;
+  return location.vcs && !exports_protected.isHome(location.directory) ? fffLayer : ripgrepLayer;
+}));
+function configured(options) {
+  return makeLocationNode2({ service: Service2, layer: layer(options), deps: [exports_location.node, exports_ripgrep.node] });
+}
+var node2 = configured();
+
+export { Options, Service2 as Service, ripgrepLayer, fffLayer, layer, configured, node2 as node, exports_search, FindInput, ReadInput, Content, ListInput, DEFAULT_SEARCH_LIMIT, DEFAULT_SEARCH_TIMEOUT_MS, GlobInput, GrepInput, Event, Service as Service1, node as node1, exports_filesystem, Entry2 as Entry, Match, Submatch };

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

@@ -0,0 +1,17 @@
+import {
+  ProjectTable
+} from "./location-mutation-88jbfw8z.js";
+import {
+  absoluteColumn
+} from "./location-mutation-zbqqnp0n.js";
+
+// src/worktree/sql.ts
+import { integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+var WorktreeTable = sqliteTable("worktree", {
+  project_id: text().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+  directory: absoluteColumn().notNull(),
+  strategy: text(),
+  time_created: integer().notNull().$default(() => Date.now())
+}, (table) => [primaryKey({ columns: [table.project_id, table.directory] })]);
+
+export { WorktreeTable };

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

@@ -0,0 +1,79 @@
+import {
+  SQLiteEffectPreparedQuery,
+  SQLiteEffectSession,
+  SQLiteEffectTransaction
+} from "./location-mutation-9314w1nf.js";
+
+// src/database/drizzle/effect-sqlite/session.ts
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Scope from "effect/Scope";
+import { entityKind } from "drizzle-orm/entity";
+function managesTransactionsNatively(client) {
+  return client.transactionStatements === false;
+}
+
+class EffectSQLiteSession extends SQLiteEffectSession {
+  client;
+  relations;
+  options;
+  static [entityKind] = "EffectSQLiteSession";
+  constructor(client, dialect, relations, options) {
+    super(dialect);
+    this.client = client;
+    this.relations = relations;
+    this.options = options;
+  }
+  prepareQuery(query, fields, executeMethod, customResultMapper, queryMetadata, cacheConfig) {
+    return new SQLiteEffectPreparedQuery((params, method) => this.execute(query, params, method), query, this.options.logger, this.options.cache, queryMetadata, cacheConfig, fields, executeMethod, this.options.useJitMappers, customResultMapper, undefined, undefined, this.isInTransaction());
+  }
+  prepareRelationalQuery(query, fields, executeMethod, customResultMapper, config) {
+    return new SQLiteEffectPreparedQuery((params, method) => this.execute(query, params, method), query, this.options.logger, this.options.cache, undefined, undefined, fields, executeMethod, this.options.useJitMappers, customResultMapper, true, config, this.isInTransaction());
+  }
+  execute(query, params, method) {
+    const statement = this.client.unsafe(query.sql, params);
+    if (method === "values")
+      return statement.values;
+    if (method === "get")
+      return statement.withoutTransform.pipe(Effect.map((rows) => rows[0]));
+    return statement.withoutTransform;
+  }
+  isInTransaction() {
+    return Effect.serviceOption(this.client.transactionService).pipe(Effect.map((option) => option._tag === "Some"));
+  }
+  executeTransactionStatement(connection, query) {
+    return connection.executeUnprepared(query, [], undefined).pipe(Effect.asVoid);
+  }
+  withTransaction(effect, config) {
+    if (managesTransactionsNatively(this.client))
+      return this.client.withTransaction(effect);
+    return Effect.uninterruptibleMask((restore) => Effect.withFiber((fiber) => {
+      const services = fiber.context;
+      const connectionOption = Context.getOption(services, this.client.transactionService);
+      const connection = connectionOption._tag === "Some" ? Effect.succeed([undefined, connectionOption.value[0]]) : Scope.make().pipe(Effect.flatMap((scope) => Scope.provide(this.client.reserve, scope).pipe(Effect.map((connection2) => [scope, connection2]), Effect.catch((error) => Scope.close(scope, Exit.fail(error)).pipe(Effect.andThen(Effect.fail(error)))))));
+      const id = connectionOption._tag === "Some" ? connectionOption.value[1] + 1 : 0;
+      return connection.pipe(Effect.flatMap(([scope, connection2]) => {
+        const transaction = this.executeTransactionStatement(connection2, id === 0 ? `begin ${config?.behavior ?? "deferred"}` : `savepoint effect_sql_${id}`).pipe(Effect.flatMap(() => Effect.provideContext(restore(effect), Context.add(services, this.client.transactionService, [connection2, id])).pipe(Effect.exit, Effect.flatMap((exit2) => {
+          const finalize = Exit.isSuccess(exit2) ? id === 0 ? this.executeTransactionStatement(connection2, "commit").pipe(Effect.catch((error) => this.executeTransactionStatement(connection2, "rollback").pipe(Effect.catch(() => Effect.void), Effect.andThen(Effect.fail(error))))) : this.executeTransactionStatement(connection2, `release savepoint effect_sql_${id}`) : id === 0 ? this.executeTransactionStatement(connection2, "rollback") : this.executeTransactionStatement(connection2, `rollback to savepoint effect_sql_${id}`).pipe(Effect.andThen(this.executeTransactionStatement(connection2, `release savepoint effect_sql_${id}`)));
+          return finalize.pipe(Effect.flatMap(() => exit2));
+        }))));
+        return scope === undefined ? transaction : transaction.pipe(Effect.onExit((exit2) => Scope.close(scope, exit2)));
+      }));
+    }));
+  }
+  transaction(transaction, config) {
+    const { dialect, relations } = this;
+    return this.withTransaction(Effect.gen({ self: this }, function* () {
+      const tx = new EffectSQLiteTransaction(dialect, this, relations);
+      return yield* transaction(tx);
+    }), config);
+  }
+}
+
+class EffectSQLiteTransaction extends SQLiteEffectTransaction {
+  static [entityKind] = "EffectSQLiteTransaction";
+  transaction = (tx) => this.session.transaction(tx);
+}
+
+export { managesTransactionsNatively, EffectSQLiteSession, EffectSQLiteTransaction };

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

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

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

@@ -0,0 +1,15 @@
+// src/database/migration/20260309230000_move_org_to_state.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260309230000_move_org_to_state",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`account_state\` ADD \`active_org_id\` text;`);
+      yield* tx.run(`UPDATE \`account_state\` SET \`active_org_id\` = (SELECT \`selected_org_id\` FROM \`account\` WHERE \`account\`.\`id\` = \`account_state\`.\`active_account_id\`);`);
+      yield* tx.run(`ALTER TABLE \`account\` DROP COLUMN \`selected_org_id\`;`);
+    });
+  }
+};
+var _20260309230000_move_org_to_state_default = migration;
+
+export { _20260309230000_move_org_to_state_default };

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

@@ -0,0 +1,130 @@
+import {
+  SnowflakeCortexPlugin
+} from "./location-mutation-we2zmhe4.js";
+import {
+  KiloPlugin
+} from "./location-mutation-cgvnqv92.js";
+import {
+  OpenRouterPlugin
+} from "./location-mutation-3vh42rcr.js";
+import {
+  VercelPlugin
+} from "./location-mutation-9r0qzhnf.js";
+import {
+  GroqPlugin
+} from "./location-mutation-ayfwnm78.js";
+import {
+  OpenAIPlugin
+} from "./location-mutation-fa4tegb4.js";
+import {
+  CoherePlugin
+} from "./location-mutation-qe0d689s.js";
+import {
+  OpencodePlugin
+} from "./location-mutation-6vhc8gnm.js";
+import {
+  GitLabPlugin
+} from "./location-mutation-3w0f1yxt.js";
+import {
+  GatewayPlugin
+} from "./location-mutation-smpeg8c9.js";
+import {
+  CerebrasPlugin
+} from "./location-mutation-10xtr3be.js";
+import {
+  TogetherAIPlugin
+} from "./location-mutation-jssy2dr3.js";
+import {
+  AzurePlugin
+} from "./location-mutation-zmj71pz5.js";
+import {
+  ZenmuxPlugin
+} from "./location-mutation-56p2m126.js";
+import {
+  DynamicProviderPlugin
+} from "./location-mutation-3q6gbwmd.js";
+import {
+  VenicePlugin
+} from "./location-mutation-xwftk1fd.js";
+import {
+  LLMGatewayPlugin
+} from "./location-mutation-v29v7e1s.js";
+import {
+  NvidiaPlugin
+} from "./location-mutation-fm1nvm5g.js";
+import {
+  XAIPlugin
+} from "./location-mutation-880b4y2j.js";
+import {
+  AlibabaPlugin
+} from "./location-mutation-4zzdwbaz.js";
+import {
+  SapAICorePlugin
+} from "./location-mutation-857g7h76.js";
+import {
+  OpenAICompatiblePlugin
+} from "./location-mutation-fmyre8m1.js";
+import {
+  CloudflareAIGatewayPlugin
+} from "./location-mutation-pvwwwbxa.js";
+import {
+  GoogleVertexPlugin
+} from "./location-mutation-ts4t4v20.js";
+import {
+  PerplexityPlugin
+} from "./location-mutation-wps8gh8n.js";
+import {
+  CloudflareWorkersAIPlugin
+} from "./location-mutation-2e8rafee.js";
+import {
+  AnthropicPlugin
+} from "./location-mutation-ddn74qps.js";
+import {
+  MistralPlugin
+} from "./location-mutation-3thh6229.js";
+import {
+  AmazonBedrockPlugin
+} from "./location-mutation-rqswsgbs.js";
+import {
+  DeepInfraPlugin
+} from "./location-mutation-pfqehjmy.js";
+import {
+  GithubCopilotPlugin
+} from "./location-mutation-2j4g542v.js";
+
+// src/plugin/provider.ts
+var ProviderPlugins = [
+  AlibabaPlugin,
+  AmazonBedrockPlugin,
+  AnthropicPlugin,
+  AzurePlugin,
+  CerebrasPlugin,
+  CloudflareAIGatewayPlugin,
+  CloudflareWorkersAIPlugin,
+  CoherePlugin,
+  DeepInfraPlugin,
+  GatewayPlugin,
+  GithubCopilotPlugin,
+  GitLabPlugin,
+  GoogleVertexPlugin,
+  GroqPlugin,
+  KiloPlugin,
+  LLMGatewayPlugin,
+  MistralPlugin,
+  NvidiaPlugin,
+  OpencodePlugin,
+  SnowflakeCortexPlugin,
+  OpenAICompatiblePlugin,
+  OpenAIPlugin,
+  OpenRouterPlugin,
+  PerplexityPlugin,
+  SapAICorePlugin,
+  TogetherAIPlugin,
+  VercelPlugin,
+  VenicePlugin,
+  XAIPlugin,
+  ZenmuxPlugin,
+  DynamicProviderPlugin
+];
+
+export { ProviderPlugins };

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

@@ -0,0 +1,18 @@
+import {
+  ProjectTable
+} from "./location-mutation-88jbfw8z.js";
+import {
+  Timestamps
+} from "./location-mutation-sem2g21k.js";
+
+// src/permission/sql.ts
+import { sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+var PermissionTable = sqliteTable("permission", {
+  id: text().$type().primaryKey(),
+  project_id: text().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+  action: text().notNull(),
+  resource: text().notNull(),
+  ...Timestamps
+}, (table) => [uniqueIndex("permission_project_action_resource_idx").on(table.project_id, table.action, table.resource)]);
+
+export { PermissionTable };