@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-06jas3ts.js

@@ -0,0 +1,117 @@
+import {
+  exports_mcp
+} from "./permission-qnjh8g89.js";
+import {
+  exports_tool
+} from "./permission-2qdvkq1m.js";
+import {
+  exports_permission
+} from "./permission-qa8qg9jd.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/tool/mcp.ts
+var exports_mcp2 = {};
+__export(exports_mcp2, {
+  node: () => node,
+  namespace: () => namespace,
+  name: () => name,
+  layer: () => layer,
+  Service: () => Service,
+  McpTool: () => exports_mcp2
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { McpEvent } from "@opencode-ai/schema/mcp-event";
+import { Context, Effect, Exit, Fiber, Layer, Scope, Semaphore, Stream } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+var namespace = (server) => server.replace(/[^a-zA-Z0-9_-]/g, "_");
+var name = (server, tool) => `${namespace(server)}_${tool.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+
+class Service extends Context.Service()("@opencode/McpTool") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const mcp = yield* exports_mcp.Service;
+  const tools = yield* exports_tool.Service;
+  const bus = yield* exports_bus.Service;
+  const permission = yield* exports_permission.Service;
+  const scope = yield* Scope.Scope;
+  const lock = Semaphore.makeUnsafe(1);
+  let current;
+  const reconcile = lock.withPermit(Effect.gen(function* () {
+    const discovered = yield* mcp.tools();
+    const next = yield* Scope.fork(scope);
+    yield* tools.transform((draft) => {
+      for (const tool of discovered) {
+        const schema = tool.inputSchema ?? {};
+        draft.add({
+          name: tool.name,
+          options: { namespace: namespace(tool.server), codemode: tool.codemode !== false },
+          description: tool.description ?? "",
+          input: {
+            ...schema,
+            type: "object",
+            properties: schema.properties ?? {},
+            additionalProperties: false
+          },
+          output: tool.outputSchema ?? {},
+          execute: (input, context) => Effect.gen(function* () {
+            yield* permission.assert({
+              action: name(tool.server, tool.name),
+              resources: ["*"],
+              save: ["*"],
+              metadata: {},
+              sessionID: context.sessionID,
+              agent: context.agent,
+              source: {
+                type: "tool",
+                messageID: context.messageID,
+                id: context.id
+              }
+            });
+            const result = yield* mcp.callTool({
+              server: tool.server,
+              name: tool.name,
+              args: input ?? {}
+            }).pipe(Effect.catchTags({
+              "MCP.NotFoundError": (error) => new ToolFailure({ message: `MCP server "${error.server}" is not available` }),
+              "MCP.ToolCallError": (error) => new ToolFailure({ message: error.message })
+            }));
+            if (result.isError)
+              return yield* new ToolFailure({
+                message: result.content.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+`).trim() || "MCP tool returned an error"
+              });
+            const content = result.content.map((part) => part.type === "text" ? { type: "text", text: part.text } : {
+              type: "file",
+              uri: `data:${part.mimeType};base64,${part.data}`,
+              mime: part.mimeType
+            });
+            const text = content.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+`);
+            return {
+              output: result.structured ?? (text === "" ? null : text),
+              ...content.length === 0 ? {} : { content }
+            };
+          }).pipe(Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to execute ${name(tool.server, tool.name)}` })))
+        });
+      }
+    }).pipe(Scope.provide(next), Effect.orDie);
+    if (current)
+      yield* Scope.close(current, Exit.void);
+    current = next;
+  }));
+  const initial = yield* reconcile.pipe(Effect.forkScoped);
+  yield* bus.subscribe(McpEvent.ToolsChanged).pipe(Stream.runForEach(() => reconcile), Effect.forkScoped({ startImmediately: true }));
+  return Service.of({ flush: Effect.asVoid(Fiber.await(initial)) });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_tool.node, exports_mcp.node, exports_bus.node, exports_permission.node]
+});
+
+export { namespace, name, Service, layer, node, exports_mcp2 as exports_mcp };

package/dist/chunks/permission-08m6gcy4.js

@@ -0,0 +1,126 @@
+import {
+  exports_kv
+} from "./permission-y76hsvs9.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  exports_state
+} from "./permission-wt193r4g.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/websearch.ts
+var exports_websearch = {};
+__export(exports_websearch, {
+  node: () => node,
+  WebSearch: () => exports_websearch,
+  Service: () => Service,
+  Result: () => Result,
+  Response: () => Response,
+  RequestError: () => RequestError,
+  ProviderRequiredError: () => ProviderRequiredError,
+  ProviderNotFoundError: () => ProviderNotFoundError,
+  Provider: () => Provider,
+  Input: () => Input,
+  ID: () => ID,
+  Event: () => Event,
+  DisabledError: () => DisabledError
+});
+import { WebSearch } from "@opencode-ai/schema/websearch";
+import { Context, Effect, Layer, Schema } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Event } from "@opencode-ai/schema/websearch";
+var ID = WebSearch.ID;
+var Provider = WebSearch.Provider;
+var Input = WebSearch.Input;
+var Result = WebSearch.Result;
+var Response = WebSearch.Response;
+
+class ProviderRequiredError extends Schema.TaggedErrorClass()("WebSearch.ProviderRequired", {}) {
+}
+
+class ProviderNotFoundError extends Schema.TaggedErrorClass()("WebSearch.ProviderNotFound", {
+  providerID: ID
+}) {
+}
+
+class DisabledError extends Schema.TaggedErrorClass()("WebSearch.Disabled", {}) {
+}
+
+class RequestError extends Schema.TaggedErrorClass()("WebSearch.Request", {
+  providerID: ID,
+  cause: Schema.Defect()
+}) {
+}
+
+class Service extends Context.Service()("@opencode/WebSearch") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const kv = yield* exports_kv.Service;
+  const decodeResults = Schema.decodeUnknownEffect(Schema.Array(Result));
+  const state = exports_state.create({
+    initial: () => ({ providers: new Map }),
+    draft: (draft) => ({
+      add: (provider) => draft.providers.set(provider.id, provider),
+      default: {
+        get: () => draft.defaultProviderID,
+        set: (providerID) => draft.defaultProviderID = providerID
+      }
+    }),
+    finalize: () => bus.publish(WebSearch.Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  const requireProvider = (providers, providerID) => {
+    const provider = providers.get(providerID);
+    return provider ? Effect.succeed(provider) : Effect.fail(new ProviderNotFoundError({ providerID }));
+  };
+  const defaultProvider = Effect.fn("WebSearch.default")(function* () {
+    const data = state.get();
+    const configured = data.defaultProviderID ? data.providers.get(data.defaultProviderID) : undefined;
+    if (configured)
+      return configured;
+    const stored = yield* kv.get("websearch:provider");
+    if (stored === false)
+      return yield* new DisabledError;
+    if (typeof stored !== "string")
+      return;
+    return data.providers.get(ID.make(stored));
+  });
+  const resolve = Effect.fn("WebSearch.resolve")(function* (input) {
+    const providers = state.get().providers;
+    if (input.providerID)
+      return yield* requireProvider(providers, input.providerID);
+    const provider = yield* defaultProvider();
+    if (!provider)
+      return yield* new ProviderRequiredError;
+    return provider;
+  });
+  return Service.of({
+    transform: state.transform,
+    reload: state.reload,
+    providers: Effect.fn("WebSearch.providers")(function* () {
+      return Array.from(state.get().providers.values(), (provider) => ({
+        id: provider.id,
+        name: provider.name
+      })).toSorted((a, b) => a.name.localeCompare(b.name));
+    }),
+    default: Effect.fn("WebSearch.defaultInfo")(function* () {
+      const provider = yield* defaultProvider();
+      return provider && { id: provider.id, name: provider.name };
+    }),
+    query: Effect.fn("WebSearch.query")(function* (input) {
+      const provider = yield* resolve(input);
+      const results = yield* provider.execute({ query: input.query }).pipe(Effect.flatMap(decodeResults), Effect.mapError((cause) => new RequestError({ providerID: provider.id, cause })));
+      return new Response({ providerID: provider.id, results });
+    })
+  });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_bus.node, exports_kv.node]
+});
+
+export { ID, Provider, Input, Result, Response, ProviderRequiredError, ProviderNotFoundError, DisabledError, RequestError, Service, node, exports_websearch, Event };

package/dist/chunks/permission-0c101nc9.js

@@ -0,0 +1,116 @@
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  exports_state
+} from "./permission-wt193r4g.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/agent.ts
+var exports_agent = {};
+__export(exports_agent, {
+  node: () => node,
+  defaultID: () => defaultID,
+  Service: () => Service,
+  Name: () => Name,
+  Info: () => Info,
+  ID: () => ID,
+  Event: () => Event,
+  Color: () => Color,
+  Agent: () => exports_agent
+});
+import path from "path";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Array, Context, Effect, Layer } from "effect";
+import { Agent } from "@opencode-ai/schema/agent";
+import { Global } from "@opencode-ai/util/global";
+import { Event } from "@opencode-ai/schema/agent";
+var SHELL_OUTPUT_GLOB = (data) => path.join(data, "shell", "*", "*");
+var TOOL_OUTPUT_GLOB = (data) => path.join(data, "tool-output", "*");
+var ID = Agent.ID;
+var Name = Agent.Name;
+var defaultID = ID.make("build");
+var Color = Agent.Color;
+var Info = Agent.Info;
+
+class Service extends Context.Service()("@opencode/Agent") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const global = yield* Global.Service;
+  const permissions = [
+    { action: "external_directory", resource: SHELL_OUTPUT_GLOB(global.data), effect: "allow" },
+    { action: "external_directory", resource: TOOL_OUTPUT_GLOB(global.data), effect: "allow" },
+    { action: "external_directory", resource: path.join(global.tmp, "*"), effect: "allow" },
+    { action: "external_directory", resource: path.join(global.config, "*"), effect: "allow" }
+  ];
+  const state = exports_state.create({
+    name: "agent",
+    initial: () => ({ agents: new Map }),
+    draft: (draft) => ({
+      list: () => Array.fromIterable(draft.agents.values()),
+      get: (id) => draft.agents.get(id),
+      default: (id) => {
+        draft.default = id;
+      },
+      update: (id, fn) => {
+        const defaults = Info.default(id);
+        const current = draft.agents.get(id) ?? {
+          ...defaults,
+          permissions: [...defaults.permissions, ...permissions]
+        };
+        if (!draft.agents.has(id))
+          draft.agents.set(id, current);
+        fn(current);
+        current.id = id;
+      },
+      remove: (id) => {
+        draft.agents.delete(id);
+      }
+    }),
+    finalize: () => bus.publish(Agent.Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  const selectable = (agent) => agent && agent.mode !== "subagent" && !agent.hidden ? agent : undefined;
+  const selectedDefault = () => {
+    const data = state.get();
+    const configured = data.default ? selectable(data.agents.get(data.default)) : undefined;
+    if (configured)
+      return configured;
+    const build = selectable(data.agents.get(ID.make("build")));
+    if (build)
+      return build;
+    for (const agent of data.agents.values()) {
+      const fallback = selectable(agent);
+      if (fallback)
+        return fallback;
+    }
+  };
+  return Service.of({
+    transform: state.transform,
+    reload: state.reload,
+    get: Effect.fn("Agent.get")(function* (id) {
+      return state.get().agents.get(id);
+    }),
+    resolve: Effect.fn("Agent.resolve")(function* (id) {
+      if (id !== undefined)
+        return state.get().agents.get(ID.make(id));
+      return selectedDefault();
+    }),
+    select: Effect.fn("Agent.select")(function* (id) {
+      if (id !== undefined) {
+        const selected = ID.make(id);
+        return { id: selected, info: state.get().agents.get(selected) };
+      }
+      const info = selectedDefault();
+      return { id: info?.id ?? defaultID, info };
+    }),
+    list: Effect.fn("Agent.list")(function* () {
+      return Array.fromIterable(state.get().agents.values());
+    })
+  });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_bus.node, Global.node] });
+
+export { ID, Name, defaultID, Color, Info, Service, node, exports_agent, Event };

package/dist/chunks/permission-0cgt0xh2.js

@@ -0,0 +1,18 @@
+// src/github-copilot/chat/map-openai-compatible-finish-reason.ts
+function mapOpenAICompatibleFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "other";
+  }
+}
+
+export { mapOpenAICompatibleFinishReason };

package/dist/chunks/permission-0cm1xtm8.js

@@ -0,0 +1,85 @@
+import {
+  MessageDecodeError
+} from "./permission-s6by3cc4.js";
+import {
+  exports_instruction_state
+} from "./permission-bha9y19b.js";
+import {
+  exports_message
+} from "./permission-25pxtba7.js";
+import {
+  SessionMessageTable
+} from "./permission-zvvp2xr4.js";
+import {
+  exports_schema
+} from "./permission-y8rs54ne.js";
+import {
+  exports_instructions
+} from "./permission-q4r4pzs4.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/history.ts
+var exports_history = {};
+__export(exports_history, {
+  preview: () => preview,
+  load: () => load,
+  latestCompaction: () => latestCompaction,
+  firstUserMessage: () => firstUserMessage,
+  entriesForRunner: () => entriesForRunner,
+  SessionHistory: () => exports_history
+});
+import { and, asc, desc, eq, gte, sql } from "drizzle-orm";
+import { Effect, Schema } from "effect";
+var decode = Schema.decodeUnknownEffect(exports_message.Info);
+var latestCompaction = Effect.fnUntraced(function* (db, sessionID) {
+  return yield* db.select({ seq: SessionMessageTable.seq }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, sessionID), eq(SessionMessageTable.type, "compaction"), sql`json_extract(${SessionMessageTable.data}, '$.status') = 'completed'`)).orderBy(desc(SessionMessageTable.seq)).limit(1).get().pipe(Effect.orDie);
+});
+var messageRows = Effect.fnUntraced(function* (db, sessionID, compaction) {
+  const rows = yield* db.select().from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, sessionID), compaction ? gte(SessionMessageTable.seq, compaction.seq) : undefined)).orderBy(asc(SessionMessageTable.seq)).all().pipe(Effect.orDie);
+  return rows;
+});
+var decodeMessageRow = (row) => decode({ ...row.data, id: row.id, type: row.type }).pipe(Effect.mapError(() => new MessageDecodeError({
+  sessionID: exports_schema.ID.make(row.session_id),
+  messageID: exports_message.ID.make(row.id)
+})));
+var messageEntries = Effect.fnUntraced(function* (db, sessionID) {
+  const rows = yield* messageRows(db, sessionID, yield* latestCompaction(db, sessionID));
+  return yield* Effect.forEach(rows, (row) => decodeMessageRow(row).pipe(Effect.map((message) => ({ seq: row.seq, message }))));
+});
+var load = Effect.fn("SessionHistory.load")(function* (db, sessionID) {
+  return (yield* messageEntries(db, sessionID)).map((entry) => entry.message);
+});
+var entriesForRunner = Effect.fn("SessionHistory.entriesForRunner")(function* (db, sessionID, instructions) {
+  return yield* db.transaction(() => Effect.gen(function* () {
+    const messages = yield* messageEntries(db, sessionID);
+    return {
+      initial: yield* exports_instruction_state.initial(db, sessionID, instructions),
+      entries: messages
+    };
+  })).pipe(Effect.orDie);
+});
+var preview = Effect.fn("SessionHistory.preview")(function* (db, sessionID, instructions) {
+  const observed = yield* exports_instructions.read(instructions);
+  return yield* db.transaction(() => Effect.gen(function* () {
+    const messages = yield* messageEntries(db, sessionID);
+    const unsettled = messages.findIndex((entry) => entry.message.type === "assistant" && entry.message.time.completed === undefined);
+    const settled = unsettled === -1 ? messages : messages.slice(0, unsettled);
+    const assembled = yield* exports_instruction_state.preview(db, sessionID, instructions, observed);
+    return {
+      initial: assembled.initial,
+      messages: settled.map((entry) => entry.message),
+      instructionUpdate: assembled.update
+    };
+  })).pipe(Effect.catch((error) => error instanceof exports_instructions.InitializationBlocked ? error : Effect.die(error)));
+});
+var firstUserMessage = Effect.fn("SessionHistory.firstUserMessage")(function* (db, sessionID) {
+  const row = yield* db.select().from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, sessionID), eq(SessionMessageTable.type, "user"))).orderBy(asc(SessionMessageTable.seq)).get().pipe(Effect.orDie);
+  if (!row)
+    return;
+  const message = yield* decodeMessageRow(row).pipe(Effect.catch(() => Effect.succeed(undefined)));
+  return message?.type === "user" ? message : undefined;
+});
+
+export { latestCompaction, load, entriesForRunner, preview, firstUserMessage, exports_history };

package/dist/chunks/permission-0emnz988.js

@@ -0,0 +1,130 @@
+import {
+  exports_config
+} from "./permission-k59zb4v2.js";
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/config/plugin/provider.ts
+var exports_provider2 = {};
+__export(exports_provider2, {
+  Plugin: () => Plugin,
+  ConfigProviderPlugin: () => exports_provider2
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Money } from "@opencode-ai/schema/money";
+import { Effect, Stream } from "effect";
+var Plugin = define({
+  id: "opencode.config.provider",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* exports_config.Service;
+    const loaded = { entries: yield* config.entries() };
+    yield* ctx.integration.transform((integrations) => {
+      for (const [id, provider] of configuredProviders(loaded.entries)) {
+        const integrationID = id;
+        if (!integrations.get(integrationID)) {
+          integrations.method.update({
+            integrationID,
+            method: { type: "key", label: "Manually enter API Key" }
+          });
+        }
+        integrations.update(integrationID, (integration) => {
+          integration.name = provider.name ?? integration.name;
+        });
+        if (provider.env !== undefined) {
+          integrations.method.update({
+            integrationID,
+            method: { type: "env", names: [...provider.env] }
+          });
+        }
+      }
+    });
+    yield* ctx.catalog.transform((catalog) => {
+      const configuredDefault = exports_config.latest(loaded.entries, "model");
+      if (configuredDefault !== undefined)
+        catalog.model.default.set(configuredDefault.providerID, configuredDefault.model);
+      for (const [id, item] of configuredProviders(loaded.entries)) {
+        const providerID = id;
+        catalog.provider.update(providerID, (provider) => {
+          if (item.name !== undefined)
+            provider.name = item.name;
+          if (item.package !== undefined)
+            provider.package = item.package;
+          if (item.settings !== undefined)
+            provider.settings = exports_provider.mergeOverlay(provider.settings, item.settings);
+          if (item.headers !== undefined)
+            provider.headers = exports_provider.mergeHeaders(provider.headers, item.headers);
+          if (item.body !== undefined)
+            provider.body = exports_provider.mergeOverlay(provider.body, item.body);
+        });
+        for (const [id2, config2] of Object.entries(item.models ?? {})) {
+          catalog.model.update(providerID, id2, (model) => {
+            if (config2.family !== undefined)
+              model.family = config2.family;
+            if (config2.name !== undefined)
+              model.name = config2.name;
+            if (config2.modelID !== undefined)
+              model.modelID = config2.modelID;
+            if (config2.compatibility !== undefined)
+              model.compatibility = { ...model.compatibility, ...config2.compatibility };
+            if (config2.package !== undefined)
+              model.package = config2.package;
+            if (config2.settings !== undefined)
+              model.settings = exports_provider.mergeOverlay(model.settings, config2.settings);
+            if (config2.headers !== undefined)
+              model.headers = exports_provider.mergeHeaders(model.headers, config2.headers);
+            if (config2.body !== undefined)
+              model.body = exports_provider.mergeOverlay(model.body, config2.body);
+            if (config2.capabilities !== undefined) {
+              model.capabilities = {
+                tools: config2.capabilities.tools,
+                input: [...config2.capabilities.input],
+                output: [...config2.capabilities.output]
+              };
+            }
+            if (config2.variants !== undefined) {
+              model.variants ??= [];
+              for (const variant of config2.variants) {
+                let existing = model.variants.find((item2) => item2.id === variant.id);
+                if (!existing) {
+                  existing = { id: variant.id };
+                  model.variants.push(existing);
+                }
+                if (variant.settings !== undefined)
+                  existing.settings = exports_provider.mergeOverlay(existing.settings, variant.settings);
+                if (variant.headers !== undefined)
+                  existing.headers = exports_provider.mergeHeaders(existing.headers, variant.headers);
+                if (variant.body !== undefined)
+                  existing.body = exports_provider.mergeOverlay(existing.body, variant.body);
+              }
+            }
+            if (config2.cost !== undefined) {
+              model.cost = (Array.isArray(config2.cost) ? config2.cost : [config2.cost]).map((cost) => ({
+                tier: cost.tier && { ...cost.tier },
+                input: cost.input,
+                output: cost.output,
+                cache: {
+                  read: cost.cache?.read ?? Money.USDPerMillionTokens.zero,
+                  write: cost.cache?.write ?? Money.USDPerMillionTokens.zero
+                }
+              }));
+            }
+            if (config2.disabled !== undefined)
+              model.enabled = !config2.disabled;
+            if (config2.limit !== undefined)
+              model.limit = { ...model.limit, ...config2.limit };
+          });
+        }
+      }
+    });
+    yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(() => config.entries().pipe(Effect.tap((entries) => Effect.sync(() => loaded.entries = entries)), Effect.andThen(ctx.integration.reload()), Effect.andThen(ctx.catalog.reload()))), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+function configuredProviders(entries) {
+  return entries.filter((entry) => entry.type === "document").flatMap((file) => Object.entries(file.info.providers ?? {}));
+}
+
+export { Plugin, exports_provider2 as exports_provider };

package/dist/chunks/permission-0f48qthw.js

@@ -0,0 +1,32 @@
+// src/database/drizzle/sqlite-core/effect/count.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import { SQL, sql } from "drizzle-orm/sql/sql";
+function buildSQLiteEmbeddedCount(source, filters) {
+  return sql`(select count(*) from ${source}${sql.raw(" where ").if(filters)}${filters})`;
+}
+function buildSQLiteCount(source, filters) {
+  return sql`select count(*) from ${source}${sql.raw(" where ").if(filters)}${filters}`;
+}
+
+class SQLiteEffectCountBuilder extends SQL {
+  static [entityKind] = "SQLiteEffectCountBuilder";
+  sql;
+  session;
+  constructor(params) {
+    super(buildSQLiteEmbeddedCount(params.source, params.filters).queryChunks);
+    this.session = params.session;
+    this.sql = buildSQLiteCount(params.source, params.filters);
+  }
+  execute(placeholderValues) {
+    return this.session.prepareQuery(this.session.dialect.sqlToQuery(this.sql), undefined, "all", (rows) => {
+      const v = rows[0]?.[0];
+      if (typeof v === "number")
+        return v;
+      return v ? Number(v) : 0;
+    }).execute(placeholderValues);
+  }
+}
+applyEffectWrapper(SQLiteEffectCountBuilder);
+
+export { SQLiteEffectCountBuilder };

package/dist/chunks/permission-0kvmztkf.js

@@ -0,0 +1,31 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/effect/keyed-mutex.ts
+var exports_keyed_mutex = {};
+__export(exports_keyed_mutex, {
+  makeUnsafe: () => makeUnsafe,
+  make: () => make,
+  KeyedMutex: () => exports_keyed_mutex
+});
+import { Effect, Semaphore } from "effect";
+var makeUnsafe = () => {
+  const locks = new Map;
+  const withLock = (key) => (effect) => Effect.suspend(() => {
+    const current = locks.get(key);
+    const entry = current ?? { semaphore: Semaphore.makeUnsafe(1), users: 0 };
+    if (!current)
+      locks.set(key, entry);
+    entry.users++;
+    return entry.semaphore.withPermit(effect).pipe(Effect.ensuring(Effect.sync(() => {
+      entry.users--;
+      if (entry.users === 0)
+        locks.delete(key);
+    })));
+  });
+  return { size: Effect.sync(() => locks.size), withLock };
+};
+var make = () => Effect.sync(makeUnsafe);
+
+export { makeUnsafe, make, exports_keyed_mutex };