apps 0.0.1-beta.3 → 0.0.1-beta.31

package/js/{chunk-RN2MXB4R.js → chunk-3FJYVAE4.js}

@@ -1,26 +1,32 @@
 import {
   prepareElicitation
-} from "./chunk-J7O55ZV7.js";
+} from "./chunk-W7F23NQ2.js";
 import {
   fromPromise
-} from "./chunk-PYUYJRSK.js";
+} from "./chunk-5XJR4XGW.js";
+import {
+  bodyUpstreamError
+} from "./chunk-4OKYLVU4.js";
 import {
   ElicitationFailed,
   McpError,
+  McpServerHeader,
   McpToolMetadata,
   McpToolResult,
+  RouterIcon,
   ToolResultObservation,
   defaultElicitationLimits,
   defaultMcpClientLimits,
   mcpSdkTimerCeilingMs
-} from "./chunk-MYYEW3RA.js";
+} from "./chunk-N72RKJ5E.js";
 import {
-  compileJsonSchemaDecoder,
-  jsonSchemaDecoder
-} from "./chunk-WFSQXYUT.js";
+  jsonSchemaDecoder,
+  nestJsonSchema,
+  preparedJsonSchemaDecoder
+} from "./chunk-NPGRURDG.js";
 import {
   JsonObject
-} from "./chunk-SATWJKN6.js";
+} from "./chunk-FBBXFFFJ.js";
 import {
   Clock_exports,
   Deferred_exports,
@@ -29,29 +35,79 @@ import {
   Option_exports,
   Queue_exports,
   Schema_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-EXGKN554.js";
 
 // src/implementation/mcp-tools.ts
+var resultFields = {
+  content: { type: "array", items: { type: "object" } },
+  structuredContent: { type: "object" },
+  isError: { type: "boolean" },
+  _meta: { type: "object" }
+};
+var definitionReference = /^#\/(?:\$defs|definitions)\/[^/]+$/;
+var locating = /* @__PURE__ */ new Set(["$id", "$anchor", "$dynamicAnchor", "$recursiveAnchor"]);
+var onlyDefinitionReferences = (value) => Array.isArray(value) ? value.every(onlyDefinitionReferences) : value === null || typeof value !== "object" ? true : Object.entries(value).every(
+  ([key, item]) => locating.has(key) || key === "$dynamicRef" || key === "$recursiveRef" ? false : key === "$ref" ? typeof item === "string" && definitionReference.test(item) : onlyDefinitionReferences(item)
+);
+var placed = (structuredContent, pointer) => {
+  if (onlyDefinitionReferences(structuredContent)) {
+    const { $defs, definitions, $schema: _draft, ...schema } = structuredContent;
+    return {
+      schema,
+      root: {
+        ...$defs === void 0 ? {} : { $defs },
+        ...definitions === void 0 ? {} : { definitions }
+      }
+    };
+  }
+  try {
+    return { schema: nestJsonSchema(structuredContent, pointer), root: {} };
+  } catch {
+    return { schema: structuredContent, root: {} };
+  }
+};
+var resultSchema = (structuredContent) => {
+  if (structuredContent === void 0)
+    return { type: "object", properties: resultFields, required: ["content"] };
+  const { schema, root } = placed(structuredContent, "#/anyOf/0/properties/structuredContent");
+  return {
+    // The envelope's keywords mean the same in every draft, so the server's draft applies.
+    ...structuredContent.$schema === void 0 ? {} : { $schema: structuredContent.$schema },
+    ...root,
+    anyOf: [
+      {
+        type: "object",
+        properties: { ...resultFields, structuredContent: schema, isError: { const: false } },
+        required: ["content", "structuredContent"]
+      },
+      {
+        type: "object",
+        properties: { ...resultFields, isError: { const: true } },
+        required: ["content", "isError"]
+      }
+    ]
+  };
+};
 var adaptMcpTool = (client, tool) => Effect_exports.gen(function* () {
   const decoder = yield* jsonSchemaDecoder(tool.inputSchema).pipe(
     Effect_exports.mapError(() => new McpError({ phase: "schema", reason: "invalid_response" }))
   );
-  const output = tool.outputSchema === void 0 ? void 0 : yield* Effect_exports.cached(
-    compileJsonSchemaDecoder(tool.outputSchema).pipe(
-      Effect_exports.mapError(() => new McpError({ phase: "schema", reason: "invalid_response" }))
-    )
-  );
+  const output = preparedJsonSchemaDecoder(resultSchema(tool.outputSchema));
+  const { outputSchema: _upstream, ...metadata } = tool;
   const adapted = {
-    ...tool,
+    ...metadata,
     description: tool.description ?? tool.title ?? tool.name,
     input: decoder,
+    output: output.decoder,
     ...tool.annotations?.readOnlyHint === void 0 ? {} : { readOnly: tool.annotations.readOnlyHint },
     run: (context, input) => Effect_exports.gen(function* () {
       const arguments_ = yield* Schema_exports.decodeUnknownEffect(decoder)(input).pipe(
         Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(JsonObject)),
         Effect_exports.mapError(() => new McpError({ phase: "call", reason: "invalid_input" }))
       );
-      const outputDecoder = output === void 0 ? void 0 : yield* output;
+      yield* output.compile.pipe(
+        Effect_exports.mapError(() => new McpError({ phase: "schema", reason: "invalid_response" }))
+      );
       const result = yield* client.call(tool.name, arguments_, context);
       if (result.isError === true) {
         (yield* ToolResultObservation).failed();
@@ -60,17 +116,13 @@ var adaptMcpTool = (client, tool) => Effect_exports.gen(function* () {
           "error.type": "McpToolError"
         });
       }
-      if (outputDecoder !== void 0 && !result.isError)
-        yield* Schema_exports.decodeUnknownEffect(outputDecoder)(result.structuredContent).pipe(
-          Effect_exports.mapError(() => new McpError({ phase: "call", reason: "invalid_response" }))
-        );
       return result;
     })
   };
   return adapted;
 });
 var adaptMcpTools = (client) => Effect_exports.gen(function* () {
-  const metadata = yield* client.list;
+  const { tools: metadata } = yield* client.list;
   const entries = yield* Effect_exports.forEach(
     metadata,
     (tool) => adaptMcpTool(client, tool).pipe(Effect_exports.map((adapted) => [tool.name, adapted]))
@@ -79,7 +131,11 @@ var adaptMcpTools = (client) => Effect_exports.gen(function* () {
 });
 
 // src/implementation/mcp-client.ts
-import { ListToolsResultSchema } from "@modelcontextprotocol/sdk/types.js";
+import {
+  ErrorCode as ErrorCode2,
+  ListToolsResultSchema,
+  McpError as ProtocolError2
+} from "@modelcontextprotocol/sdk/types.js";
 
 // src/implementation/mcp-call.ts
 import {
@@ -208,6 +264,20 @@ var mcpCall = (client, name, input, context, timeoutMs, failure) => Effect_expor
 );
 
 // src/implementation/mcp-client.ts
+var clientCodes = /* @__PURE__ */ new Set([
+  ErrorCode2.RequestTimeout,
+  ErrorCode2.ConnectionClosed
+]);
+var answeredError = (error) => {
+  if (!(error instanceof ProtocolError2) || clientCodes.has(error.code)) return void 0;
+  const prefix = `MCP error ${error.code}: `;
+  return bodyUpstreamError({
+    error: {
+      code: error.code,
+      message: error.message.startsWith(prefix) ? error.message.slice(prefix.length) : error.message
+    }
+  });
+};
 var mcpJsonSchemaValidator = {
   getValidator(document) {
     const decoder = Effect_exports.runSync(jsonSchemaDecoder(document));
@@ -233,7 +303,7 @@ function mcpClient(withClient, timeoutMs, failure) {
       do {
         const page = yield* Effect_exports.tryPromise({
           // This session only reads metadata. listTools() also eagerly compiles
-          // every output validator; mcpOperations validates the selected tool on call.
+          // every output validator; mcpRouter validates the selected tool on call.
           try: (signal) => client.request(
             { method: "tools/list", params: cursor === void 0 ? {} : { cursor } },
             ListToolsResultSchema,
@@ -263,18 +333,52 @@ function mcpClient(withClient, timeoutMs, failure) {
           cursors.add(cursor);
         }
       } while (cursor !== void 0);
-      return [...tools.values()];
+      const info = client.getServerVersion();
+      const instructions = client.getInstructions();
+      const icons = info?.icons?.flatMap(
+        (icon) => Option_exports.toArray(Schema_exports.decodeUnknownOption(RouterIcon)(icon))
+      );
+      const server = Schema_exports.decodeUnknownOption(McpServerHeader)({
+        ...info?.name === void 0 ? {} : { name: info.name },
+        ...info?.title === void 0 ? {} : { title: info.title },
+        ...info?.version === void 0 ? {} : { version: info.version },
+        ...info?.description === void 0 ? {} : { description: info.description },
+        ...info?.websiteUrl === void 0 ? {} : { websiteUrl: info.websiteUrl },
+        ...icons === void 0 ? {} : { icons },
+        ...instructions === void 0 ? {} : { instructions }
+      });
+      return {
+        tools: [...tools.values()],
+        server: Option_exports.getOrElse(server, () => ({}))
+      };
     })
   ).pipe(Effect_exports.withSpan("provider.mcp.discover"));
+  const check = withClient(
+    "discover",
+    (client) => Effect_exports.tryPromise({
+      try: (signal) => client.request({ method: "tools/list", params: {} }, ListToolsResultSchema, {
+        signal,
+        timeout: timeoutMs
+      }),
+      catch: (error) => failure("discover", error)
+    }).pipe(
+      Effect_exports.asVoid,
+      Effect_exports.withSpan("provider.mcp.request", {
+        kind: "client",
+        attributes: { "rpc.system.name": "jsonrpc", "rpc.method": "tools/list" }
+      })
+    )
+  ).pipe(Effect_exports.withSpan("provider.mcp.check"));
   const call = (name, input, context) => withClient("call", (client) => mcpCall(client, name, input, context, timeoutMs, failure)).pipe(
     Effect_exports.withSpan("provider.mcp.call", { attributes: { "mcp.tool.name": name } })
   );
-  return { list, call };
+  return { list, check, call };
 }
 
 export {
   adaptMcpTool,
   adaptMcpTools,
+  answeredError,
   mcpJsonSchemaValidator,
   mcpClient
 };

package/js/chunk-4OKYLVU4.js

@@ -0,0 +1,118 @@
+import {
+  ProviderError,
+  maxUpstreamMessageLength
+} from "./chunk-5DLG2FVN.js";
+import {
+  AccountId
+} from "./chunk-FBBXFFFJ.js";
+import {
+  Option_exports,
+  Schema_exports
+} from "./chunk-EXGKN554.js";
+
+// src/implementation/upstream-error.ts
+var ErrorToken = Schema_exports.String.check(Schema_exports.isPattern(/^[A-Za-z0-9._-]{1,128}$/));
+var JsonRpcError = Schema_exports.Struct({
+  error: Schema_exports.Struct({ code: Schema_exports.Int, message: Schema_exports.String })
+});
+var OAuthError = Schema_exports.Struct({
+  error: ErrorToken,
+  error_description: Schema_exports.optional(Schema_exports.String)
+});
+var bounded = (message) => message.length <= maxUpstreamMessageLength ? message : `${message.slice(0, maxUpstreamMessageLength - 1)}\u2026`;
+var isShortenedUpstream = (message) => message.length === maxUpstreamMessageLength && message.endsWith("\u2026");
+var stated = (code, message) => ({
+  code,
+  ...message === void 0 || message === "" ? {} : { message: bounded(message) }
+});
+var bodyUpstreamError = (json) => {
+  const rpc = Schema_exports.decodeUnknownOption(JsonRpcError)(json);
+  if (Option_exports.isSome(rpc)) return stated(rpc.value.error.code, rpc.value.error.message);
+  const oauth = Schema_exports.decodeUnknownOption(OAuthError)(json);
+  if (Option_exports.isSome(oauth)) return stated(oauth.value.error, oauth.value.error_description);
+  return void 0;
+};
+var authParam = /([A-Za-z][A-Za-z0-9_-]*)\s*=\s*(?:"((?:[^"\\]|\\.)*)"|([^\s,"]+))/g;
+var challengeUpstreamError = (header) => {
+  const bearer = header === void 0 ? -1 : header.search(/\bBearer\b/i);
+  if (header === void 0 || bearer === -1) return void 0;
+  const params = /* @__PURE__ */ new Map();
+  for (const [, name, quoted, token] of header.slice(bearer + "Bearer".length).matchAll(authParam))
+    if (name !== void 0 && !params.has(name.toLowerCase()))
+      params.set(name.toLowerCase(), quoted?.replace(/\\(.)/g, "$1") ?? token ?? "");
+  const code = Schema_exports.decodeUnknownOption(ErrorToken)(params.get("error"));
+  return Option_exports.isNone(code) ? void 0 : stated(code.value, params.get("error_description"));
+};
+
+// src/implementation/provider-error.ts
+var providerError = ({
+  reason,
+  status,
+  accountId,
+  phase,
+  upstream
+}) => new ProviderError({
+  reason,
+  ...status === void 0 ? {} : { status },
+  ...accountId === void 0 ? {} : { accountId },
+  ...phase === void 0 ? {} : { phase },
+  ...upstream === void 0 ? {} : { upstream }
+});
+function parseProviderError(error) {
+  return Schema_exports.decodeUnknownOption(ProviderError)(error).pipe(Option_exports.map(providerError));
+}
+function providerErrorDetail(error, detail) {
+  return providerError({
+    ...error,
+    phase: error.phase ?? detail.phase,
+    upstream: error.upstream ?? detail.upstream
+  });
+}
+function httpProviderError(status, headers = {}) {
+  const upstream = challengeUpstreamError(headers["www-authenticate"]);
+  if (status >= 500 && status <= 599)
+    return providerError({ reason: "unavailable", status, upstream });
+  if (status === 401) return providerError({ reason: "unauthorized", status, upstream });
+  if (status === 429) return providerError({ reason: "rate_limited", status, upstream });
+  if (status !== 403) return void 0;
+  const retry = headers["retry-after"];
+  if (headers["x-ratelimit-remaining"] === "0" || retry !== void 0 && (/^\d+$/.test(retry) || Number.isFinite(Date.parse(retry))))
+    return providerError({ reason: "rate_limited", status, upstream });
+  if (typeof upstream?.code === "string" && upstream.code.toLowerCase() === "insufficient_scope")
+    return providerError({ reason: "forbidden", status, upstream });
+  return providerError({ reason: "rejected", status, upstream });
+}
+function accountProviderError(error, accountId) {
+  const parsed = parseProviderError(error);
+  const account = Schema_exports.decodeUnknownOption(AccountId)(accountId);
+  if (Option_exports.isNone(parsed) || Option_exports.isNone(account)) return error;
+  return providerError({ ...parsed.value, accountId: account.value });
+}
+function graphqlProviderError(errors, status) {
+  const codes = errors.flatMap((error) => {
+    const parsed = Schema_exports.decodeUnknownOption(
+      Schema_exports.Struct({
+        type: Schema_exports.optional(Schema_exports.String),
+        extensions: Schema_exports.optional(Schema_exports.Struct({ code: Schema_exports.optional(Schema_exports.String) }))
+      })
+    )(error);
+    return Option_exports.isSome(parsed) ? [parsed.value.type, parsed.value.extensions?.code] : [];
+  });
+  if (codes.includes("RATE_LIMITED") || codes.includes("TOO_MANY_REQUESTS"))
+    return new ProviderError({ reason: "rate_limited", status });
+  if (codes.includes("UNAUTHENTICATED"))
+    return new ProviderError({ reason: "unauthorized", status });
+  if (codes.includes("FORBIDDEN")) return new ProviderError({ reason: "forbidden", status });
+  return void 0;
+}
+
+export {
+  isShortenedUpstream,
+  bodyUpstreamError,
+  providerError,
+  parseProviderError,
+  providerErrorDetail,
+  httpProviderError,
+  accountProviderError,
+  graphqlProviderError
+};

package/js/{chunk-LGIYBDWA.js → chunk-5DLG2FVN.js}

@@ -1,6 +1,55 @@
+import {
+  AccountId
+} from "./chunk-FBBXFFFJ.js";
 import {
   Schema_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-EXGKN554.js";
+
+// src/contracts/failure.ts
+var maxFailureMessageLength = 2048;
+var FailureSource = Schema_exports.Literals(["app", "storage", "service"]);
+var FailureName = Schema_exports.String.check(Schema_exports.isMaxLength(128));
+var FailureCode = Schema_exports.String.check(Schema_exports.isMaxLength(128));
+var FailureMessage = Schema_exports.String.check(Schema_exports.isMaxLength(maxFailureMessageLength));
+var maxFailureFields = 8;
+var maxFailureFieldLength = 256;
+var FailureFieldName = Schema_exports.String.check(
+  Schema_exports.isPattern(/^[A-Za-z_$][A-Za-z0-9_$]{0,63}$/)
+);
+var FailureFieldValue = Schema_exports.Union([
+  Schema_exports.String.check(Schema_exports.isMaxLength(maxFailureFieldLength)),
+  Schema_exports.Finite,
+  Schema_exports.Boolean
+]);
+var FailureFields = Schema_exports.Record(FailureFieldName, FailureFieldValue).check(
+  Schema_exports.isMaxProperties(maxFailureFields)
+);
+var FailureDetail = {
+  source: Schema_exports.optionalKey(FailureSource),
+  errorName: Schema_exports.optionalKey(FailureName),
+  code: Schema_exports.optionalKey(FailureCode),
+  message: Schema_exports.optionalKey(FailureMessage),
+  fields: Schema_exports.optionalKey(FailureFields)
+};
+var maxUpstreamMessageLength = 1024;
+var UpstreamError = Schema_exports.Struct({
+  code: Schema_exports.Union([
+    Schema_exports.Int,
+    Schema_exports.String.check(Schema_exports.isMinLength(1), Schema_exports.isMaxLength(128))
+  ]),
+  message: Schema_exports.optionalKey(Schema_exports.String.check(Schema_exports.isMaxLength(maxUpstreamMessageLength)))
+});
+var FailurePhase = Schema_exports.Literals(["connect", "discover", "call"]);
+
+// src/contracts/provider-error.ts
+var ProviderError = class extends Schema_exports.TaggedError()("ProviderError", {
+  reason: Schema_exports.Literals(["unauthorized", "forbidden", "rate_limited", "unavailable", "rejected"]),
+  status: Schema_exports.optional(Schema_exports.Int.check(Schema_exports.isBetween({ minimum: 100, maximum: 599 }))),
+  accountId: Schema_exports.optional(AccountId),
+  phase: Schema_exports.optional(FailurePhase),
+  upstream: Schema_exports.optional(UpstreamError)
+}) {
+};
 
 // ../app-cache/src/contracts/cache.ts
 var CacheError = class extends Schema_exports.TaggedError()("CacheError", {
@@ -76,6 +125,21 @@ var CacheReply = Schema_exports.Union([
 ]);
 
 export {
+  maxFailureMessageLength,
+  FailureSource,
+  FailureName,
+  FailureCode,
+  FailureMessage,
+  maxFailureFields,
+  maxFailureFieldLength,
+  FailureFieldName,
+  FailureFieldValue,
+  FailureFields,
+  FailureDetail,
+  maxUpstreamMessageLength,
+  UpstreamError,
+  FailurePhase,
+  ProviderError,
   CacheError,
   cacheLimits,
   CacheEntry,

package/js/{chunk-PLCMJREA.js → chunk-5JVNM3CQ.js}

@@ -1,5 +1,7 @@
 import {
   AppDatabaseError,
+  DatabaseFieldReserved,
+  DatabaseLimitExceeded,
   DatabaseLimits,
   DatabaseOperation,
   DatabaseSchema,
@@ -8,18 +10,21 @@ import {
   Row,
   RowMetadata,
   defaultDatabaseLimits,
-  defaultDatabaseRuntimeLimits
-} from "./chunk-BMOIAIVR.js";
+  defaultDatabaseRuntimeLimits,
+  reservedFieldNames
+} from "./chunk-UMCMZFXW.js";
 import {
+  Cause_exports,
   Clock_exports,
   Effect_exports,
   Encoding_exports,
   Schema_exports,
   Semaphore_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-EXGKN554.js";
 
 // ../app-data/src/implementation/schema.ts
-var metadata = /* @__PURE__ */ new Set(["id", "createdAt", "updatedAt"]);
+var metadata = new Set(reservedFieldNames);
+var reserved = (name) => metadata.has(name);
 var indexesFor = (table) => [{ name: "by_creation", fields: [] }, ...table.indexes].map((index) => ({
   name: index.name,
   fields: [
@@ -33,23 +38,25 @@ var validScalar = (field, value) => field.kind === "number" ? typeof value === "
   return point !== void 0 && point >= 55296 && point <= 57343;
 });
 var parseDatabaseSchema = (input) => Schema_exports.decodeUnknownEffect(DatabaseSchema)(input).pipe(
+  Effect_exports.mapError(() => new AppDatabaseError({ reason: "schema" })),
   Effect_exports.flatMap(
     (schema) => Effect_exports.gen(function* () {
-      for (const table of Object.values(schema)) {
-        if (Object.keys(table.fields).some((name) => metadata.has(name)) || new Set(table.indexes.map((index) => index.name)).size !== table.indexes.length)
+      for (const [name, table] of Object.entries(schema)) {
+        const field = Object.keys(table.fields).find(reserved);
+        if (field !== void 0) return yield* new DatabaseFieldReserved({ table: name, field });
+        if (new Set(table.indexes.map((index) => index.name)).size !== table.indexes.length)
           return yield* new AppDatabaseError({ reason: "schema" });
-        for (const field of Object.values(table.fields)) {
-          if ((field.kind === "id" ? field.references === void 0 : field.references !== void 0) || field.default !== void 0 && !validScalar(field, field.default) || field.references !== void 0 && !Object.hasOwn(schema, field.references))
+        for (const field2 of Object.values(table.fields)) {
+          if ((field2.kind === "id" ? field2.references === void 0 : field2.references !== void 0) || field2.default !== void 0 && !validScalar(field2, field2.default) || field2.references !== void 0 && !Object.hasOwn(schema, field2.references))
             return yield* new AppDatabaseError({ reason: "schema" });
         }
         for (const index of table.indexes)
-          if (index.name === "by_creation" || new Set(index.fields).size !== index.fields.length || index.fields.some((name) => fieldFor(table, name) === void 0))
+          if (index.name === "by_creation" || new Set(index.fields).size !== index.fields.length || index.fields.some((name2) => fieldFor(table, name2) === void 0))
             return yield* new AppDatabaseError({ reason: "schema" });
       }
       return schema;
     })
-  ),
-  Effect_exports.mapError(() => new AppDatabaseError({ reason: "schema" }))
+  )
 );
 var canonicalSchema = (schema) => JSON.stringify(
   Object.fromEntries(
@@ -248,7 +255,12 @@ var decodeBody = Schema_exports.decodeUnknownEffect(Schema_exports.fromJsonStrin
 var storageError = () => new AppDatabaseError({ reason: "storage" });
 var makeSqliteDatabase = (options) => Effect_exports.gen(function* () {
   const { sql, crypto } = options;
-  const schema = yield* parseDatabaseSchema(options.schema);
+  const schema = yield* parseDatabaseSchema(options.schema).pipe(
+    Effect_exports.catchTag(
+      "DatabaseFieldReserved",
+      () => Effect_exports.fail(new AppDatabaseError({ reason: "schema" }))
+    )
+  );
   const limits = yield* Schema_exports.decodeUnknownEffect(DatabaseLimits)(
     options.limits ?? defaultDatabaseLimits
   ).pipe(Effect_exports.mapError(() => new AppDatabaseError({ reason: "limit" })));
@@ -295,7 +307,13 @@ var makeSqliteDatabase = (options) => Effect_exports.gen(function* () {
       };
       const charge = (name, amount) => Effect_exports.suspend(() => {
         used[name] += amount;
-        return used[name] > limits[name] ? Effect_exports.fail(new AppDatabaseError({ reason: "limit" })) : Effect_exports.void;
+        return used[name] > limits[name] ? Effect_exports.fail(
+          new DatabaseLimitExceeded({
+            limit: name,
+            maximum: limits[name],
+            requested: used[name]
+          })
+        ) : Effect_exports.void;
       });
       const get = (table, id) => Effect_exports.gen(function* () {
         yield* charge("directGets", 1);
@@ -312,8 +330,13 @@ var makeSqliteDatabase = (options) => Effect_exports.gen(function* () {
       const store = (tableName, table, row) => Effect_exports.gen(function* () {
         const meta = yield* Schema_exports.decodeUnknownEffect(RowMetadata)(row);
         const body = JSON.stringify(row);
-        if (new TextEncoder().encode(body).length > limits.valueBytes)
-          return yield* new AppDatabaseError({ reason: "limit" });
+        const bytes = new TextEncoder().encode(body).length;
+        if (bytes > limits.valueBytes)
+          return yield* new DatabaseLimitExceeded({
+            limit: "valueBytes",
+            maximum: limits.valueBytes,
+            requested: bytes
+          });
         const keys = yield* Effect_exports.forEach(
           indexesFor(table),
           (index) => encodeIndexKey(
@@ -384,9 +407,14 @@ var makeSqliteDatabase = (options) => Effect_exports.gen(function* () {
               const bounds = yield* queryBounds(table, plan, limits.indexBytes);
               reads.add(tableName);
               yield* charge("scanCalls", 1);
-              const maximum = terminal.kind === "count" ? limits.rowsRead - used.rowsRead : limits.rowsReturned - used.rowsReturned;
-              const count = terminal.kind === "first" ? 1 : terminal.kind === "take" ? terminal.count : terminal.kind === "paginate" ? terminal.numItems : maximum;
-              if (count > maximum) return yield* new AppDatabaseError({ reason: "limit" });
+              const remaining = terminal.kind === "count" ? limits.rowsRead - used.rowsRead : limits.rowsReturned - used.rowsReturned;
+              const count = terminal.kind === "first" ? 1 : terminal.kind === "take" ? terminal.count : terminal.kind === "paginate" ? terminal.numItems : remaining;
+              if ((terminal.kind === "take" || terminal.kind === "paginate") && count > limits.rowsReturned)
+                return yield* new DatabaseLimitExceeded({
+                  limit: "pageSize",
+                  maximum: limits.rowsReturned,
+                  requested: count
+                });
               if (count === 0 && terminal.kind === "take") return [];
               const query = yield* fingerprint(
                 crypto,
@@ -412,7 +440,10 @@ var makeSqliteDatabase = (options) => Effect_exports.gen(function* () {
                   plan.order === "asc" ? sql`i.sort_key > ${position}` : sql`i.sort_key < ${position}`
                 );
               const direction = plan.order === "asc" ? sql.literal("ASC") : sql.literal("DESC");
-              const limit = terminal.kind === "first" || terminal.kind === "take" ? count : count + 1;
+              const limit = Math.min(
+                terminal.kind === "first" || terminal.kind === "take" ? count : count + 1,
+                remaining + 1
+              );
               if (terminal.kind === "count") {
                 const rows2 = yield* sql`SELECT i.sort_key FROM app_indexes i WHERE ${sql.and(predicates)} ORDER BY i.sort_key ${direction} LIMIT ${limit}`.pipe(
                   Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(Schema_exports.Array(CountRow)))
@@ -436,7 +467,11 @@ var makeSqliteDatabase = (options) => Effect_exports.gen(function* () {
                 )
               );
               if (terminal.kind === "collect" && rows.length > count)
-                return yield* new AppDatabaseError({ reason: "limit" });
+                return yield* new DatabaseLimitExceeded({
+                  limit: "rowsReturned",
+                  maximum: limits.rowsReturned,
+                  requested: used.rowsReturned + rows.length
+                });
               const page = rows.slice(0, count);
               yield* charge("rowsReturned", page.length);
               const values = yield* Effect_exports.forEach(page, (row) => decodeBody(row.body));
@@ -502,6 +537,11 @@ var makeSqliteDatabase = (options) => Effect_exports.gen(function* () {
         })
       };
       return yield* Effect_exports.suspend(() => work(session)).pipe(
+        // A failed database call poisons the session. Report that failure even when
+        // authored code caught it or threw something else in its place.
+        Effect_exports.catchCause(
+          (cause) => failed === void 0 || Cause_exports.hasInterrupts(cause) ? Effect_exports.failCause(cause) : Effect_exports.fail(failed)
+        ),
         Effect_exports.tap(
           () => gate.withPermits(1)(
             Effect_exports.suspend(() => failed === void 0 ? Effect_exports.void : Effect_exports.fail(failed))