@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-kwn61asm.js

@@ -0,0 +1,42 @@
+import {
+  Service35
+} from "./aisdk-native-y9tfvs3x.js";
+import {
+  Service8
+} from "./aisdk-native-rmbt0h7x.js";
+import {
+  observe2
+} from "./aisdk-native-qsdy395h.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/config/plugin/compaction.ts
+var exports_compaction = {};
+__export(exports_compaction, {
+  ConfigCompactionPlugin: () => exports_compaction,
+  Plugin: () => Plugin7
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect } from "effect";
+var Plugin7 = define({
+  id: "opencode.config.compaction",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service35;
+    const compaction = yield* Service8;
+    const loaded = yield* observe2(config, ctx.event, compaction.reload());
+    yield* compaction.transform((editor) => {
+      for (const entry of loaded.entries) {
+        if (entry.type !== "document" || !entry.info.compaction)
+          continue;
+        editor.configure({
+          ...entry.info.compaction.auto === undefined ? {} : { auto: entry.info.compaction.auto },
+          ...entry.info.compaction.buffer === undefined ? {} : { buffer: entry.info.compaction.buffer },
+          ...entry.info.compaction.keep?.tokens === undefined ? {} : { tokens: entry.info.compaction.keep.tokens }
+        });
+      }
+    });
+  })
+});
+
+export { Plugin7, exports_compaction };

package/dist/chunks/aisdk-native-m9w0rfyh.js

@@ -0,0 +1,123 @@
+import {
+  getTableColumnsRuntime2,
+  getViewSelectedFieldsRuntime2,
+  orderSelectedFields2,
+  mapUpdateSet2,
+  getTableLikeName2
+} from "./aisdk-native-emrn6kk6.js";
+
+// src/database/drizzle/sqlite-core/effect/update.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind, is } from "drizzle-orm/entity";
+import { SelectionProxyHandler } from "drizzle-orm/selection-proxy";
+import { SQLiteTable } from "drizzle-orm/sqlite-core/table";
+import { extractUsedTable } from "drizzle-orm/sqlite-core/utils";
+import { SQLiteViewBase } from "drizzle-orm/sqlite-core/view-base";
+import { Subquery } from "drizzle-orm/subquery";
+class SQLiteEffectUpdateBuilder2 {
+  table;
+  session;
+  dialect;
+  withList;
+  static [entityKind] = "SQLiteEffectUpdateBuilder";
+  constructor(table, session, dialect, withList) {
+    this.table = table;
+    this.session = session;
+    this.dialect = dialect;
+    this.withList = withList;
+  }
+  set(values) {
+    return new SQLiteEffectUpdateBase2(this.table, mapUpdateSet2(this.table, values), this.session, this.dialect, this.withList);
+  }
+}
+
+class SQLiteEffectUpdateBase2 {
+  effectSession;
+  effectDialect;
+  static [entityKind] = "SQLiteEffectUpdate";
+  config;
+  constructor(table, set, effectSession, effectDialect, withList) {
+    this.effectSession = effectSession;
+    this.effectDialect = effectDialect;
+    this.config = { set, table, withList, joins: [] };
+  }
+  from(source) {
+    this.config.from = source;
+    return this;
+  }
+  createJoin(joinType) {
+    return (table, on) => {
+      const tableName = getTableLikeName2(table);
+      if (typeof tableName === "string" && this.config.joins.some((join) => join.alias === tableName)) {
+        throw new Error(`Alias "${tableName}" is already used in this query`);
+      }
+      if (typeof on === "function") {
+        const from = this.config.from ? is(table, SQLiteTable) ? getTableColumnsRuntime2(table) : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? getViewSelectedFieldsRuntime2(table).selectedFields : undefined : undefined;
+        on = on(new Proxy(getTableColumnsRuntime2(this.config.table), new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })), from && new Proxy(from, new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })));
+      }
+      this.config.joins.push({ on, table, joinType, alias: tableName });
+      return this;
+    };
+  }
+  leftJoin = this.createJoin("left");
+  rightJoin = this.createJoin("right");
+  innerJoin = this.createJoin("inner");
+  fullJoin = this.createJoin("full");
+  where(where) {
+    this.config.where = where;
+    return this;
+  }
+  orderBy(...columns) {
+    if (typeof columns[0] === "function") {
+      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;
+    }
+    this.config.orderBy = columns;
+    return this;
+  }
+  limit(limit) {
+    this.config.limit = limit;
+    return this;
+  }
+  returning(fields = getTableColumnsRuntime2(this.config.table)) {
+    this.config.returning = orderSelectedFields2(fields);
+    return this;
+  }
+  getSQL() {
+    return this.effectDialect.buildUpdateQuery(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: "update",
+      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(SQLiteEffectUpdateBase2);
+
+export { SQLiteEffectUpdateBuilder2, SQLiteEffectUpdateBase2 };

package/dist/chunks/aisdk-native-mb3974r6.js

@@ -0,0 +1,79 @@
+import {
+  SQLiteEffectPreparedQuery2,
+  SQLiteEffectSession2,
+  SQLiteEffectTransaction2
+} from "./aisdk-native-wggajky5.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 managesTransactionsNatively2(client) {
+  return client.transactionStatements === false;
+}
+
+class EffectSQLiteSession2 extends SQLiteEffectSession2 {
+  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 SQLiteEffectPreparedQuery2((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 SQLiteEffectPreparedQuery2((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.pipe(Effect.withTracerEnabled(false));
+    if (method === "get")
+      return statement.withoutTransform.pipe(Effect.map((rows) => rows[0]), Effect.withTracerEnabled(false));
+    return statement.withoutTransform.pipe(Effect.withTracerEnabled(false));
+  }
+  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 (managesTransactionsNatively2(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((connection) => [scope, connection]), 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, connection]) => {
+        const transaction = this.executeTransactionStatement(connection, id === 0 ? `begin ${config?.behavior ?? "deferred"}` : `savepoint effect_sql_${id}`).pipe(Effect.flatMap(() => Effect.provideContext(restore(effect), Context.add(services, this.client.transactionService, [connection, id])).pipe(Effect.exit, Effect.flatMap((exit) => {
+          const finalize = Exit.isSuccess(exit) ? id === 0 ? this.executeTransactionStatement(connection, "commit").pipe(Effect.catch((error) => this.executeTransactionStatement(connection, "rollback").pipe(Effect.catch(() => Effect.void), Effect.andThen(Effect.fail(error))))) : this.executeTransactionStatement(connection, `release savepoint effect_sql_${id}`) : id === 0 ? this.executeTransactionStatement(connection, "rollback") : this.executeTransactionStatement(connection, `rollback to savepoint effect_sql_${id}`).pipe(Effect.andThen(this.executeTransactionStatement(connection, `release savepoint effect_sql_${id}`)));
+          return finalize.pipe(Effect.flatMap(() => exit));
+        }))));
+        return scope === undefined ? transaction : transaction.pipe(Effect.onExit((exit) => Scope.close(scope, exit)));
+      }));
+    }));
+  }
+  transaction(transaction, config) {
+    const { dialect, relations } = this;
+    return this.withTransaction(Effect.gen({ self: this }, function* () {
+      const tx = new EffectSQLiteTransaction2(dialect, this, relations);
+      return yield* transaction(tx);
+    }), config);
+  }
+}
+
+class EffectSQLiteTransaction2 extends SQLiteEffectTransaction2 {
+  static [entityKind] = "EffectSQLiteTransaction";
+  transaction = (tx) => this.session.transaction(tx);
+}
+
+export { managesTransactionsNatively2, EffectSQLiteSession2, EffectSQLiteTransaction2 };

package/dist/chunks/aisdk-native-mfqp6xfm.js

@@ -0,0 +1,64 @@
+import {
+  collectBoundedResponseBody2
+} from "./aisdk-native-3v8g72cx.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/plugin/websearch/mcp.ts
+var exports_mcp2 = {};
+__export(exports_mcp2, {
+  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES2,
+  WebSearchMcp: () => exports_mcp2,
+  call: () => call2,
+  parseResponse: () => parseResponse2
+});
+import { Duration, Effect, Schema } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/unstable/http";
+var MAX_RESPONSE_BYTES2 = 256 * 1024;
+var parseResponse2 = (body, result) => {
+  const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ result })));
+  const parse = (payload) => {
+    const trimmed = payload.trim();
+    if (!trimmed.startsWith("{"))
+      return Effect.undefined;
+    return decode(trimmed).pipe(Effect.map((response) => response.result));
+  };
+  return Effect.gen(function* () {
+    const trimmed = body.trim();
+    const direct = trimmed ? yield* parse(trimmed) : undefined;
+    if (direct)
+      return direct;
+    for (const line of body.split(`
+`)) {
+      if (!line.startsWith("data: "))
+        continue;
+      const data = yield* parse(line.substring(6));
+      if (data)
+        return data;
+    }
+  });
+};
+var call2 = (http, url, tool, schema, value, headers = {}) => Effect.gen(function* () {
+  const request = yield* HttpClientRequest.post(url).pipe(HttpClientRequest.accept("application/json, text/event-stream"), HttpClientRequest.setHeaders(headers), HttpClientRequest.schemaBodyJson(Schema.Struct({
+    jsonrpc: Schema.Literal("2.0"),
+    id: Schema.Literal(1),
+    method: Schema.Literal("tools/call"),
+    params: Schema.Struct({ name: Schema.String, arguments: schema.input })
+  }))({
+    jsonrpc: "2.0",
+    id: 1,
+    method: "tools/call",
+    params: { name: tool, arguments: value }
+  }));
+  return yield* Effect.gen(function* () {
+    const response = yield* HttpClient.withScope(HttpClient.filterStatusOk(http)).execute(request);
+    const body = yield* collectBoundedResponseBody2(response, MAX_RESPONSE_BYTES2, () => new Error(`${tool} response exceeded ${MAX_RESPONSE_BYTES2} bytes`));
+    return yield* parseResponse2(body.toString("utf8"), schema.output);
+  }).pipe(Effect.scoped, Effect.timeoutOrElse({
+    duration: Duration.seconds(25),
+    orElse: () => Effect.fail(new Error(`${tool} request timed out`))
+  }));
+});
+
+export { MAX_RESPONSE_BYTES2, parseResponse2, call2, exports_mcp2 };

package/dist/chunks/aisdk-native-mhkvc446.js

@@ -0,0 +1,264 @@
+import {
+  which2
+} from "./aisdk-native-qaymkmh1.js";
+
+// src/formatter/builtins.ts
+import { Effect } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+function make9(input) {
+  const disabled = false;
+  const findExecutable = (name) => which2(name, undefined, input.bin);
+  const findUp = (target) => input.fs.findUp(target, input.directory, input.worktree);
+  const readText = (file) => input.fs.readFileString(file).pipe(Effect.orElseSucceed(() => ""));
+  const commandOutput = (command) => input.processes.run(ChildProcess.make(command[0], command.slice(1), {
+    cwd: input.directory,
+    extendEnv: true,
+    stdin: "ignore"
+  })).pipe(Effect.option);
+  const gofmt = executable("gofmt", [".go"], ["-w", "$FILE"], findExecutable);
+  const mix = executable("mix", [".ex", ".exs", ".eex", ".heex", ".leex", ".neex", ".sface"], ["format", "$FILE"], findExecutable);
+  const prettier = {
+    name: "prettier",
+    environment: { BUN_BE_BUN: "1" },
+    extensions: [
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".ts",
+      ".tsx",
+      ".mts",
+      ".cts",
+      ".html",
+      ".htm",
+      ".css",
+      ".scss",
+      ".sass",
+      ".less",
+      ".vue",
+      ".svelte",
+      ".json",
+      ".jsonc",
+      ".yaml",
+      ".yml",
+      ".toml",
+      ".xml",
+      ".md",
+      ".mdx",
+      ".graphql",
+      ".gql"
+    ],
+    enabled: Effect.gen(function* () {
+      for (const file of yield* findUp("package.json")) {
+        if (!hasDependency(yield* input.fs.readJson(file), "prettier"))
+          continue;
+        const bin = yield* input.npm.which("prettier");
+        if (bin)
+          return [bin, "--write", "$FILE"];
+      }
+      return disabled;
+    }).pipe(Effect.orElseSucceed(() => disabled))
+  };
+  const oxfmt = {
+    name: "oxfmt",
+    environment: { BUN_BE_BUN: "1" },
+    extensions: [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts"],
+    enabled: Effect.gen(function* () {
+      for (const file of yield* findUp("package.json")) {
+        if (!hasDependency(yield* input.fs.readJson(file), "oxfmt"))
+          continue;
+        const bin = yield* input.npm.which("oxfmt");
+        if (bin)
+          return [bin, "$FILE"];
+      }
+      return disabled;
+    }).pipe(Effect.orElseSucceed(() => disabled))
+  };
+  const biome = {
+    name: "biome",
+    environment: { BUN_BE_BUN: "1" },
+    extensions: [
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".ts",
+      ".tsx",
+      ".mts",
+      ".cts",
+      ".html",
+      ".htm",
+      ".css",
+      ".scss",
+      ".sass",
+      ".less",
+      ".vue",
+      ".svelte",
+      ".json",
+      ".jsonc",
+      ".yaml",
+      ".yml",
+      ".toml",
+      ".xml",
+      ".md",
+      ".mdx",
+      ".graphql",
+      ".gql"
+    ],
+    enabled: Effect.gen(function* () {
+      const found = yield* Effect.forEach(["biome.json", "biome.jsonc"], findUp, { concurrency: "unbounded" });
+      if (!found.some((items) => items.length > 0))
+        return disabled;
+      const bin = yield* input.npm.which("@biomejs/biome");
+      return bin ? [bin, "format", "--write", "$FILE"] : disabled;
+    }).pipe(Effect.orElseSucceed(() => disabled))
+  };
+  const zig = executable("zig", [".zig", ".zon"], ["fmt", "$FILE"], findExecutable);
+  const clang = {
+    name: "clang-format",
+    extensions: [".c", ".cc", ".cpp", ".cxx", ".c++", ".h", ".hh", ".hpp", ".hxx", ".h++", ".ino", ".C", ".H"],
+    enabled: Effect.gen(function* () {
+      if (!(yield* findUp(".clang-format")).length)
+        return disabled;
+      const match = findExecutable("clang-format");
+      return match ? [match, "-i", "$FILE"] : disabled;
+    }).pipe(Effect.orElseSucceed(() => disabled))
+  };
+  const ktlint = executable("ktlint", [".kt", ".kts"], ["-F", "$FILE"], findExecutable);
+  const ruff = {
+    name: "ruff",
+    extensions: [".py", ".pyi"],
+    enabled: Effect.gen(function* () {
+      const bin = findExecutable("ruff");
+      if (!bin)
+        return disabled;
+      for (const config of ["pyproject.toml", "ruff.toml", ".ruff.toml"]) {
+        const found = yield* findUp(config);
+        if (!found.length)
+          continue;
+        if (config !== "pyproject.toml" || (yield* readText(found[0])).includes("[tool.ruff]")) {
+          return [bin, "format", "$FILE"];
+        }
+      }
+      for (const dependency of ["requirements.txt", "pyproject.toml", "Pipfile"]) {
+        const found = yield* findUp(dependency);
+        if (found.length && (yield* readText(found[0])).includes("ruff"))
+          return [bin, "format", "$FILE"];
+      }
+      return disabled;
+    }).pipe(Effect.orElseSucceed(() => disabled))
+  };
+  const air = {
+    name: "air",
+    extensions: [".R"],
+    enabled: Effect.gen(function* () {
+      const bin = findExecutable("air");
+      if (!bin)
+        return disabled;
+      const output = yield* commandOutput([bin, "--help"]);
+      if (output._tag === "None" || output.value.exitCode !== 0)
+        return disabled;
+      const first = output.value.stdout.toString("utf8").split(`
+`)[0];
+      return first.includes("R language") && first.includes("formatter") ? [bin, "format", "$FILE"] : disabled;
+    })
+  };
+  const uv = {
+    name: "uv",
+    extensions: [".py", ".pyi"],
+    enabled: Effect.gen(function* () {
+      const bin = findExecutable("uv");
+      if (!bin)
+        return disabled;
+      const output = yield* commandOutput([bin, "format", "--help"]);
+      return output._tag === "Some" && output.value.exitCode === 0 ? [bin, "format", "--", "$FILE"] : disabled;
+    })
+  };
+  const rubocop = executable("rubocop", [".rb", ".rake", ".gemspec", ".ru"], ["--autocorrect", "$FILE"], findExecutable);
+  const standardrb = executable("standardrb", [".rb", ".rake", ".gemspec", ".ru"], ["--fix", "$FILE"], findExecutable);
+  const htmlbeautifier = executable("htmlbeautifier", [".erb", ".html.erb"], ["$FILE"], findExecutable);
+  const dart = executable("dart", [".dart"], ["format", "$FILE"], findExecutable);
+  const ocamlformat = {
+    name: "ocamlformat",
+    extensions: [".ml", ".mli"],
+    enabled: Effect.gen(function* () {
+      if (!(yield* findUp(".ocamlformat")).length)
+        return disabled;
+      const match = findExecutable("ocamlformat");
+      return match ? [match, "-i", "$FILE"] : disabled;
+    }).pipe(Effect.orElseSucceed(() => disabled))
+  };
+  const terraform = executable("terraform", [".tf", ".tfvars"], ["fmt", "$FILE"], findExecutable);
+  const latexindent = executable("latexindent", [".tex"], ["-w", "-s", "$FILE"], findExecutable);
+  const gleam = executable("gleam", [".gleam"], ["format", "$FILE"], findExecutable);
+  const shfmt = executable("shfmt", [".sh", ".bash"], ["-w", "$FILE"], findExecutable);
+  const nixfmt = executable("nixfmt", [".nix"], ["$FILE"], findExecutable);
+  const rustfmt = executable("rustfmt", [".rs"], ["$FILE"], findExecutable);
+  const pint = {
+    name: "pint",
+    extensions: [".php"],
+    enabled: Effect.gen(function* () {
+      for (const file of yield* findUp("composer.json")) {
+        const json = yield* input.fs.readJson(file);
+        if (hasRecordKey(json, "require", "laravel/pint") || hasRecordKey(json, "require-dev", "laravel/pint")) {
+          return ["./vendor/bin/pint", "$FILE"];
+        }
+      }
+      return disabled;
+    }).pipe(Effect.orElseSucceed(() => disabled))
+  };
+  const ormolu = executable("ormolu", [".hs"], ["-i", "$FILE"], findExecutable);
+  const cljfmt = executable("cljfmt", [".clj", ".cljs", ".cljc", ".edn"], ["fix", "--quiet", "$FILE"], findExecutable);
+  const dfmt = executable("dfmt", [".d"], ["-i", "$FILE"], findExecutable);
+  return [
+    gofmt,
+    mix,
+    oxfmt,
+    prettier,
+    biome,
+    zig,
+    clang,
+    ktlint,
+    ruff,
+    air,
+    uv,
+    rubocop,
+    standardrb,
+    htmlbeautifier,
+    dart,
+    ocamlformat,
+    terraform,
+    latexindent,
+    gleam,
+    shfmt,
+    nixfmt,
+    rustfmt,
+    pint,
+    ormolu,
+    cljfmt,
+    dfmt
+  ];
+}
+function executable(name, extensions, args, findExecutable) {
+  return {
+    name,
+    extensions,
+    enabled: Effect.sync(() => {
+      const match = findExecutable(name);
+      return match ? [match, ...args] : false;
+    })
+  };
+}
+function hasDependency(input, dependency) {
+  return hasRecordKey(input, "dependencies", dependency) || hasRecordKey(input, "devDependencies", dependency);
+}
+function hasRecordKey(input, field, key) {
+  if (!isRecord(input))
+    return false;
+  return isRecord(input[field]) && key in input[field];
+}
+function isRecord(input) {
+  return Boolean(input && typeof input === "object" && !Array.isArray(input));
+}
+
+export { make9 };

package/dist/chunks/aisdk-native-mjymc32g.js

@@ -0,0 +1,41 @@
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/v1/config/permission.ts
+var exports_permission = {};
+__export(exports_permission, {
+  Action: () => Action2,
+  ConfigPermissionV1: () => exports_permission,
+  Info: () => Info11,
+  Object: () => Object2,
+  Rule: () => Rule2
+});
+import { Schema, SchemaGetter } from "effect";
+var Action2 = Schema.Literals(["ask", "allow", "deny"]).annotate({ identifier: "PermissionActionConfig" });
+var Object2 = Schema.Record(Schema.String, Action2).annotate({ identifier: "PermissionObjectConfig" });
+var Rule2 = Schema.Union([Action2, Object2]).annotate({ identifier: "PermissionRuleConfig" });
+var InputObject = Schema.StructWithRest(Schema.Struct({
+  read: Schema.optional(Rule2),
+  edit: Schema.optional(Rule2),
+  glob: Schema.optional(Rule2),
+  grep: Schema.optional(Rule2),
+  list: Schema.optional(Rule2),
+  bash: Schema.optional(Rule2),
+  task: Schema.optional(Rule2),
+  external_directory: Schema.optional(Rule2),
+  question: Schema.optional(Action2),
+  webfetch: Schema.optional(Rule2),
+  websearch: Schema.optional(Action2),
+  lsp: Schema.optional(Rule2),
+  doom_loop: Schema.optional(Action2),
+  skill: Schema.optional(Rule2)
+}), [Schema.Record(Schema.String, Rule2)]);
+var InputSchema = Schema.Union([Action2, InputObject]);
+var normalizeInput = (input) => typeof input === "string" ? { "*": input } : input;
+var Info11 = InputSchema.pipe(Schema.decodeTo(InputObject, {
+  decode: SchemaGetter.transform(normalizeInput),
+  encode: SchemaGetter.passthrough({ strict: false })
+})).annotate({ identifier: "PermissionConfig" });
+
+export { Action2, Object2, Rule2, Info11, exports_permission };

package/dist/chunks/aisdk-native-mp448xyj.js

@@ -0,0 +1,23 @@
+// src/database/migration/20260605003541_add_session_context_snapshot.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260605003541_add_session_context_snapshot",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`session_context_epoch\` (
+          \`session_id\` text PRIMARY KEY,
+          \`baseline\` text NOT NULL,
+          \`snapshot\` text NOT NULL,
+          \`baseline_seq\` integer NOT NULL,
+          \`replacement_seq\` integer,
+          \`revision\` integer DEFAULT 0 NOT NULL,
+          CONSTRAINT \`fk_session_context_epoch_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+    });
+  }
+};
+var _20260605003541_add_session_context_snapshot_default = migration;
+
+export { _20260605003541_add_session_context_snapshot_default };