apps 0.0.1-beta.1 → 0.0.1-beta.11

package/js/chunk-Z2QY3YTF.js

@@ -0,0 +1,507 @@
+import {
+  skillFromFiles
+} from "./chunk-IPI4MFSN.js";
+import {
+  joinPath,
+  mergeMeta
+} from "./chunk-GPFVWWDZ.js";
+import {
+  parseProviderError
+} from "./chunk-MKWZPDR6.js";
+import {
+  ApiErrorResponse,
+  HostDeclarationInvalid,
+  HostEvaluationFailed,
+  HostedRouter,
+  HostedTool,
+  HostedToolSummary,
+  McpError,
+  maxFailureMessageLength
+} from "./chunk-KRSCJDTW.js";
+import {
+  AppDatabaseError
+} from "./chunk-N7YDVXYJ.js";
+import {
+  SkillLoadFailed,
+  skillFormatLimits
+} from "./chunk-JU7VHODU.js";
+import {
+  jsonSchemaDocument
+} from "./chunk-5T57N25Q.js";
+import {
+  AppStorageError,
+  AppStorageUnavailable
+} from "./chunk-PZB6T6KU.js";
+import {
+  AccountId,
+  HttpUrl,
+  JsonObject
+} from "./chunk-27F7W2LG.js";
+import {
+  Cause_exports,
+  Effect_exports,
+  Option_exports,
+  Predicate_exports,
+  Redacted_exports,
+  Result_exports,
+  Schema_exports
+} from "./chunk-CDL5PM2Q.js";
+
+// src/contracts/openapi.ts
+var OpenapiErrorResponse = Schema_exports.Struct({
+  code: ApiErrorResponse.fields.code,
+  status: ApiErrorResponse.fields.status,
+  message: Schema_exports.Union([
+    Schema_exports.Struct({ source: Schema_exports.Literal("body") }),
+    Schema_exports.Struct({ source: Schema_exports.Literal("schema"), value: ApiErrorResponse.fields.message })
+  ]),
+  schema: JsonObject
+});
+var OpenapiParameter = Schema_exports.Struct({
+  name: Schema_exports.String,
+  in: Schema_exports.Literals(["path", "query", "header", "cookie"]),
+  required: Schema_exports.optionalKey(Schema_exports.Boolean),
+  schema: Schema_exports.optionalKey(JsonObject),
+  style: Schema_exports.optionalKey(Schema_exports.String),
+  explode: Schema_exports.optionalKey(Schema_exports.Boolean),
+  allowReserved: Schema_exports.optionalKey(Schema_exports.Boolean),
+  allowEmptyValue: Schema_exports.optionalKey(Schema_exports.Boolean),
+  content: Schema_exports.optionalKey(JsonObject)
+});
+var OpenapiRequestBody = Schema_exports.Struct({
+  required: Schema_exports.optionalKey(Schema_exports.Boolean),
+  content: Schema_exports.Record(
+    Schema_exports.String,
+    Schema_exports.Struct({
+      schema: Schema_exports.optionalKey(JsonObject),
+      encoding: Schema_exports.optionalKey(JsonObject)
+    })
+  )
+});
+var OpenapiOperation = Schema_exports.Struct({
+  /** The tool name after `queries.` or `mutations.`, grouped as `<group>.<leaf>`. */
+  name: Schema_exports.NonEmptyString,
+  /** The document's operationId, when it declares one. `kinds` overrides are keyed by it. */
+  operationId: Schema_exports.optionalKey(Schema_exports.String),
+  description: Schema_exports.String,
+  method: Schema_exports.Literals(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]),
+  path: Schema_exports.String,
+  baseUrl: HttpUrl,
+  openapi: Schema_exports.String,
+  securitySchemes: Schema_exports.Record(Schema_exports.String, JsonObject),
+  /** The resolved OpenAPI Operation Object; Executor schemas remain separate. */
+  request: Schema_exports.Struct({
+    parameters: Schema_exports.Array(OpenapiParameter),
+    requestBody: Schema_exports.optionalKey(OpenapiRequestBody),
+    security: Schema_exports.Array(Schema_exports.Record(Schema_exports.String, Schema_exports.Array(Schema_exports.String))),
+    responses: Schema_exports.Record(Schema_exports.String, JsonObject)
+  }),
+  /** Streams remain in the metadata but cannot run through a single-result tool call. */
+  streaming: Schema_exports.optionalKey(Schema_exports.Literal(true)),
+  /** The operation's OpenAPI tags, shown to agents as labels within its router. */
+  tags: Schema_exports.optionalKey(Schema_exports.Array(Schema_exports.NonEmptyString)),
+  input: JsonObject,
+  outputSchema: Schema_exports.optionalKey(JsonObject),
+  errorResponses: Schema_exports.optionalKey(Schema_exports.Array(OpenapiErrorResponse))
+});
+var CredentialBinding = Schema_exports.Struct({
+  scheme: Schema_exports.String,
+  field: Schema_exports.String,
+  part: Schema_exports.Literals(["value", "username", "password"]),
+  prefix: Schema_exports.String
+});
+var OpenapiAccount = Schema_exports.Struct({
+  id: Schema_exports.optional(AccountId),
+  method: Schema_exports.String,
+  fields: Schema_exports.Record(Schema_exports.String, Schema_exports.Unknown)
+});
+var OpenapiParameterDefaults = Schema_exports.Struct({
+  path: Schema_exports.optionalKey(Schema_exports.Record(Schema_exports.String, Schema_exports.String)),
+  query: Schema_exports.optionalKey(Schema_exports.Record(Schema_exports.String, Schema_exports.String)),
+  headers: Schema_exports.optionalKey(Schema_exports.Record(Schema_exports.String, Schema_exports.String))
+});
+var OpenapiToolsOptions = Schema_exports.Struct({
+  operations: Schema_exports.Array(OpenapiOperation),
+  /**
+   * Component schemas stored once per app and referenced as `#/$defs/<name>`. Operations
+   * generated before shared definitions carry their own `$defs` and omit this.
+   */
+  definitions: Schema_exports.optional(Schema_exports.Record(Schema_exports.String, JsonObject)),
+  methods: Schema_exports.Record(Schema_exports.String, Schema_exports.Array(CredentialBinding)),
+  oauth: Schema_exports.Array(Schema_exports.String),
+  account: Schema_exports.optional(OpenapiAccount),
+  parameterDefaults: Schema_exports.optional(OpenapiParameterDefaults),
+  signal: Schema_exports.optional(Schema_exports.instanceOf(AbortSignal)),
+  fetch: Schema_exports.optional(
+    Schema_exports.declare((value) => typeof value === "function")
+  )
+});
+var OpenapiError = class extends Schema_exports.TaggedError()("OpenapiError", {
+  reason: Schema_exports.Literals(["invalid_definition", "invalid_input", "request"]),
+  status: Schema_exports.optional(Schema_exports.Number)
+}) {
+};
+var defaultOpenapiResponseLimits = {
+  maxBodyBytes: 16777216,
+  readTimeoutMs: 3e4
+};
+var isOpenapiTextMedia = (type) => /^(?:text\/|application\/(?:[\w.-]+\+)?(?:json|xml)|application\/(?:javascript|x-ndjson|x-www-form-urlencoded))/i.test(
+  type
+);
+var isOpenapiFileSchema = (shape) => shape.contentMediaType !== void 0 && shape.contentEncoding === void 0 || shape.type === "string" && shape.format === "binary";
+var openapiBinaryResultSchema = {
+  type: "object",
+  properties: {
+    base64: { type: "string", contentEncoding: "base64" },
+    contentType: { type: "string" }
+  },
+  required: ["base64", "contentType"],
+  additionalProperties: false
+};
+var openapiMediaKind = (type) => type.includes("json") && !type.includes("ndjson") ? "json" : type === "application/x-www-form-urlencoded" ? "form" : type === "multipart/form-data" ? "multipart" : isOpenapiTextMedia(type) ? "text" : "binary";
+
+// src/implementation/failure-detail.ts
+var storageMessages = {
+  schema: "The app's database schema is invalid.",
+  schema_changed: "The app's database schema changed during this operation. Retry it.",
+  table: "The operation used a table the app's database schema does not declare.",
+  index: "The operation used an index the table does not declare, or used it incorrectly.",
+  range: "The index range is invalid for the declared index.",
+  value: "A value does not match the table's declared field schema.",
+  readonly: "Queries cannot write. Move writes into a mutation.",
+  cursor: "The pagination cursor is invalid or belongs to a different query.",
+  limit: "The operation exceeded a per-invocation app data limit.",
+  closed: "The database session closed before this operation finished.",
+  storage: "App storage failed to complete the operation.",
+  replay: "A workflow step replayed with different input than its first run."
+};
+var minimumSecretLength = 6;
+var secretValues = (value, found) => {
+  if (typeof value === "string") {
+    if (value.length >= minimumSecretLength) found.add(value);
+  } else if (Array.isArray(value)) for (const item of value) secretValues(item, found);
+  else if (Predicate_exports.isObject(value))
+    for (const item of Object.values(value)) secretValues(item, found);
+  return found;
+};
+var accountFieldSecrets = (accounts) => {
+  const found = /* @__PURE__ */ new Set();
+  if (Predicate_exports.isObject(accounts)) {
+    for (const slot of Object.values(accounts))
+      for (const account of Array.isArray(slot) ? slot : [slot])
+        if (Predicate_exports.hasProperty(account, "fields")) secretValues(account.fields, found);
+  }
+  return [...found].sort((a, b) => b.length - a.length);
+};
+var accountSecrets = (accounts) => accountFieldSecrets(Redacted_exports.value(accounts));
+var boundFailureMessage = (message, secrets) => {
+  let redacted = message;
+  for (const secret of secrets) redacted = redacted.split(secret).join("[redacted]");
+  return redacted.length <= maxFailureMessageLength ? redacted : `${redacted.slice(0, maxFailureMessageLength - 1)}\u2026`;
+};
+var errorName = (error) => (error.name.length > 0 ? error.name : "Error").slice(0, 128);
+var ownMessage = (error) => {
+  const cause = error.cause;
+  const suffix = cause instanceof Error && cause.message.length > 0 ? ` (caused by ${errorName(cause)}: ${cause.message})` : "";
+  return error.message.length > 0 ? `${error.message}${suffix}` : void 0;
+};
+var describeFailure = (error) => error instanceof Error ? `${errorName(error)}: ${ownMessage(error) ?? "(no message)"}` : typeof error === "string" ? error : `A non-Error ${error === null ? "null" : typeof error} value was thrown`;
+var failureDetail = (error, secrets) => {
+  if (Schema_exports.is(AppDatabaseError)(error))
+    return {
+      source: "storage",
+      errorName: "AppDatabaseError",
+      code: error.reason,
+      message: boundFailureMessage(ownMessage(error) ?? storageMessages[error.reason], secrets)
+    };
+  if (Schema_exports.is(AppStorageUnavailable)(error))
+    return {
+      source: "storage",
+      errorName: "AppStorageUnavailable",
+      message: "App storage is not available on this host."
+    };
+  if (Schema_exports.is(AppStorageError)(error))
+    return {
+      source: "storage",
+      errorName: "AppStorageError",
+      message: "App storage failed to complete the operation."
+    };
+  if (Schema_exports.is(OpenapiError)(error))
+    return {
+      source: "service",
+      errorName: "OpenapiError",
+      code: error.reason,
+      message: error.reason === "request" ? error.status === void 0 ? "The API request failed before a response arrived." : `The API responded with HTTP ${error.status}, which its OpenAPI document does not declare as an error with a message.` : error.reason === "invalid_input" ? "The input could not be encoded as a request for this API operation." : "The API's OpenAPI definition for this operation is invalid."
+    };
+  if (error instanceof Error)
+    return {
+      source: "app",
+      errorName: errorName(error),
+      message: boundFailureMessage(
+        ownMessage(error) ?? `${errorName(error)} was thrown without a message.`,
+        secrets
+      )
+    };
+  if (typeof error === "string")
+    return { source: "app", errorName: "string", message: boundFailureMessage(error, secrets) };
+  return {
+    source: "app",
+    errorName: typeof error,
+    message: `A non-Error ${error === null ? "null" : typeof error} value was thrown.`
+  };
+};
+
+// src/implementation/router-catalog.ts
+var safeFailure = (error, secrets) => {
+  const provider = parseProviderError(error);
+  if (Option_exports.isSome(provider)) return provider.value;
+  const skills = Schema_exports.decodeUnknownOption(SkillLoadFailed)(error);
+  if (Option_exports.isSome(skills)) {
+    const { reason, message, status } = skills.value;
+    return new SkillLoadFailed({
+      reason,
+      ...message ? { message } : {},
+      ...status === void 0 ? {} : { status }
+    });
+  }
+  const mcp = Schema_exports.decodeUnknownOption(McpError)(error);
+  if (Option_exports.isSome(mcp)) {
+    const { phase, reason, status } = mcp.value;
+    return new McpError({ phase, reason, ...status === void 0 ? {} : { status } });
+  }
+  if (Schema_exports.is(HostDeclarationInvalid)(error)) return error;
+  return new HostEvaluationFailed(failureDetail(error, secrets));
+};
+var sourced = (work, secrets) => Effect_exports.suspend(work).pipe(
+  Effect_exports.catchCause(
+    (cause) => Cause_exports.hasInterrupts(cause) ? Effect_exports.interrupt : Effect_exports.fail(safeFailure(Cause_exports.squash(cause), secrets))
+  )
+);
+var routerMeta = (node, secrets) => node.kind === "router" ? Effect_exports.succeed(node.meta) : node.meta === void 0 ? Effect_exports.succeed(node.overrides) : sourced(node.meta, secrets).pipe(Effect_exports.map((meta) => mergeMeta(meta, node.overrides)));
+var routerSkillPrefix = "tools";
+var plainSegment = /^[a-z][a-z0-9]*$/;
+var pathHash = (path) => {
+  let hash = 2166136261;
+  for (let index = 0; index < path.length; index++)
+    hash = Math.imul(hash ^ path.charCodeAt(index), 16777619) >>> 0;
+  return hash.toString().padStart(10, "0");
+};
+var routerSkillName = (path) => {
+  if (path === "") return routerSkillPrefix;
+  const segments = path.split(".");
+  const plain = [routerSkillPrefix, ...segments].join("-");
+  if (segments.every((segment) => plainSegment.test(segment)) && plain.length <= skillFormatLimits.nameCharacters)
+    return plain;
+  const hash = pathHash(path);
+  const slug = path.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, skillFormatLimits.nameCharacters - routerSkillPrefix.length - hash.length - 2).replace(/^-+|-+$/g, "");
+  return [routerSkillPrefix, slug, hash].filter((part) => part !== "").join("-");
+};
+var entry = (path, meta, error) => Schema_exports.decodeUnknownEffect(HostedRouter)({
+  path,
+  ...meta?.title === void 0 ? {} : { title: meta.title },
+  ...meta?.description === void 0 ? {} : { description: meta.description },
+  ...meta?.icons === void 0 ? {} : { icons: meta.icons },
+  ...meta?.tags === void 0 ? {} : { tags: meta.tags },
+  ...meta?.instructions === void 0 ? {} : { skill: routerSkillName(path) },
+  ...error === void 0 ? {} : { error }
+}).pipe(Effect_exports.mapError(() => new HostDeclarationInvalid()));
+var invalid = (work) => work.pipe(
+  Effect_exports.catchCause(
+    (cause) => Cause_exports.hasInterrupts(cause) ? Effect_exports.interrupt : Effect_exports.fail(new HostDeclarationInvalid())
+  )
+);
+var summaryFields = (name, router, operation, schedules) => {
+  const readOnly = operation.kind === "query";
+  return {
+    name,
+    ...router === "" ? {} : { router },
+    ...schedules === void 0 ? {} : { schedules },
+    description: operation.description ?? `${readOnly ? "Query" : "Mutate"} ${name}`,
+    ...operation.title === void 0 ? {} : { title: operation.title },
+    readOnly,
+    annotations: { ...operation.annotations, readOnlyHint: readOnly }
+  };
+};
+var operationSummary = (name, router, operation, schedules) => invalid(
+  Schema_exports.decodeUnknownEffect(HostedToolSummary)(
+    summaryFields(name, router, operation, schedules)
+  )
+);
+var operationDescription = (name, router, operation, schedules) => invalid(
+  Effect_exports.gen(function* () {
+    return yield* Schema_exports.decodeUnknownEffect(HostedTool)({
+      ...summaryFields(name, router, operation, schedules),
+      inputSchema: yield* jsonSchemaDocument(operation.input),
+      ...operation.output === void 0 ? operation.outputSchema === void 0 ? {} : { outputSchema: operation.outputSchema } : { outputSchema: yield* jsonSchemaDocument(operation.output) },
+      ...operation._meta === void 0 ? {} : { _meta: operation._meta }
+    });
+  })
+);
+var fixedRouter = (operations, meta) => ({
+  kind: "dynamic",
+  ...meta === void 0 ? {} : { meta: () => Effect_exports.succeed(meta) },
+  list: () => Effect_exports.forEach(
+    Object.entries(operations),
+    ([name, operation]) => operationDescription(name, "", operation)
+  ),
+  summaries: () => Effect_exports.forEach(
+    Object.entries(operations),
+    ([name, operation]) => operationSummary(name, "", operation)
+  ),
+  describe: (name) => {
+    const operation = Object.hasOwn(operations, name) ? operations[name] : void 0;
+    return operation === void 0 ? Effect_exports.succeed(void 0) : operationDescription(name, "", operation);
+  },
+  resolve: (name) => Effect_exports.succeed(Object.hasOwn(operations, name) ? operations[name] : void 0)
+});
+var within = (wanted, path) => [...wanted].flatMap(
+  (name) => path === "" ? [name] : name.startsWith(`${path}.`) ? [name.slice(path.length + 1)] : []
+);
+var readCatalog = (root, options) => Effect_exports.gen(function* () {
+  const tools = [];
+  const routers = [];
+  const { wanted, secrets } = options;
+  const readSource = (source, path, relative) => Effect_exports.gen(function* () {
+    const describe = source.describe;
+    const [meta, listed] = yield* Effect_exports.all(
+      [
+        routerMeta(source, secrets),
+        options.summary && source.summaries !== void 0 ? sourced(source.summaries, secrets) : relative !== void 0 && describe !== void 0 ? sourced(
+          () => Effect_exports.forEach(relative, (name) => describe(name), {
+            concurrency: "unbounded"
+          }),
+          secrets
+        ).pipe(Effect_exports.map((tools2) => tools2.filter((tool) => tool !== void 0))) : sourced(source.list, secrets)
+      ],
+      { concurrency: "unbounded" }
+    );
+    const parsed = yield* Schema_exports.decodeUnknownEffect(
+      Schema_exports.Array(options.summary ? HostedToolSummary : HostedTool)
+    )(listed).pipe(Effect_exports.mapError(() => new HostDeclarationInvalid()));
+    const names = /* @__PURE__ */ new Set();
+    const found = [];
+    for (const tool of parsed) {
+      if (names.has(tool.name)) return yield* new HostDeclarationInvalid();
+      names.add(tool.name);
+      if (relative !== void 0 && !relative.includes(tool.name)) continue;
+      const readOnly = tool.readOnly === true;
+      found.push({
+        ...tool,
+        name: joinPath(path, tool.name),
+        ...path === "" ? {} : { router: path },
+        readOnly,
+        annotations: { ...tool.annotations, readOnlyHint: readOnly }
+      });
+    }
+    return { meta, found };
+  });
+  const include = (source, path, relative) => Effect_exports.gen(function* () {
+    if (path === "") {
+      const { meta, found } = yield* readSource(source, path, relative);
+      tools.push(...found);
+      return { meta, error: void 0 };
+    }
+    const result = yield* Effect_exports.result(readSource(source, path, relative));
+    if (Result_exports.isFailure(result)) return { meta: source.overrides, error: result.failure };
+    tools.push(...result.success.found);
+    return { meta: result.success.meta, error: void 0 };
+  });
+  const visit = (node, path) => Effect_exports.gen(function* () {
+    if (path !== "" || wanted === void 0 && node.meta !== void 0)
+      routers.push(yield* entry(path, node.meta));
+    for (const [key, child] of Object.entries(node.children)) {
+      const name = joinPath(path, key);
+      switch (child.kind) {
+        case "query":
+        case "mutation":
+          if (options.scheduled === true && options.schedules(name).length === 0) break;
+          if (wanted === void 0 || wanted.has(name))
+            tools.push(
+              options.summary ? yield* operationSummary(name, path, child, options.schedules(name)) : yield* operationDescription(name, path, child, options.schedules(name))
+            );
+          break;
+        case "router":
+          if (wanted === void 0 || within(wanted, name).length > 0)
+            yield* visit(child, name);
+          break;
+        case "dynamic": {
+          if (options.scheduled === true) break;
+          const relative = wanted === void 0 ? void 0 : within(wanted, name);
+          if (relative !== void 0 && relative.length === 0) break;
+          const read = yield* include(child, name, relative);
+          routers.push(yield* entry(name, read.meta, read.error));
+        }
+      }
+    }
+  });
+  if (root?.kind === "router") yield* visit(root, "");
+  else if (root?.kind === "dynamic" && options.scheduled !== true) {
+    const read = yield* include(root, "", wanted === void 0 ? void 0 : [...wanted]);
+    if (wanted === void 0 && read.meta !== void 0)
+      routers.push(yield* entry("", read.meta));
+  }
+  return { tools, routers };
+});
+var routerSkills = (root) => Effect_exports.gen(function* () {
+  const nodes = [];
+  const collect = (node, path) => {
+    nodes.push({ path, node });
+    if (node.kind === "router") {
+      for (const [key, child] of Object.entries(node.children))
+        if (child.kind === "router" || child.kind === "dynamic")
+          collect(child, joinPath(path, key));
+    }
+  };
+  if (root !== void 0) collect(root, "");
+  const skills = yield* Effect_exports.forEach(
+    nodes,
+    ({ path, node }) => (
+      // Skills that fail are skipped, so their failures are never reported.
+      routerMeta(node, []).pipe(
+        Effect_exports.flatMap((meta) => routerSkill(path, meta)),
+        Effect_exports.orElseSucceed(() => void 0)
+      )
+    ),
+    { concurrency: "unbounded" }
+  );
+  const names = /* @__PURE__ */ new Set();
+  return skills.filter((skill) => {
+    if (skill === void 0 || names.has(skill.name)) return false;
+    names.add(skill.name);
+    return true;
+  });
+});
+var routerSkill = (path, meta) => Effect_exports.gen(function* () {
+  if (meta?.instructions === void 0) return void 0;
+  const name = routerSkillName(path);
+  const description = ([meta.description, meta.title].find((text) => text !== void 0 && text.trim() !== "") ?? (path === "" ? "How to use this app's tools" : `How to use the ${path} tools`)).slice(0, skillFormatLimits.descriptionCharacters);
+  const content = `---
+name: ${name}
+description: ${JSON.stringify(description)}
+---
+
+${meta.instructions}
+`;
+  return yield* skillFromFiles([{ path: "SKILL.md", content }], { name });
+});
+
+export {
+  OpenapiErrorResponse,
+  OpenapiParameter,
+  OpenapiRequestBody,
+  OpenapiOperation,
+  OpenapiToolsOptions,
+  OpenapiError,
+  defaultOpenapiResponseLimits,
+  isOpenapiTextMedia,
+  isOpenapiFileSchema,
+  openapiBinaryResultSchema,
+  openapiMediaKind,
+  accountSecrets,
+  boundFailureMessage,
+  describeFailure,
+  failureDetail,
+  fixedRouter,
+  readCatalog,
+  routerSkills
+};

package/js/{chunk-PLCMJREA.js → chunk-ZQINWV4W.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-N7YDVXYJ.js";
 import {
+  Cause_exports,
   Clock_exports,
   Effect_exports,
   Encoding_exports,
   Schema_exports,
   Semaphore_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-CDL5PM2Q.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))