@qlever-llc/trellis 0.10.22 → 0.11.0-rc.1

package/src/contract_support/canonical.ts

@@ -194,10 +194,12 @@ export function sha256Bytes(data: Uint8Array): Uint8Array {
   return out;
 }
 
+/** Computes a synchronous SHA-256 digest encoded as base64url. */
 export function sha256Base64urlSync(text: string): string {
   return base64url(sha256Bytes(new TextEncoder().encode(text)));
 }
 
+/** Computes a SHA-256 digest encoded as base64url. */
 export async function sha256Base64url(text: string): Promise<string> {
   if (typeof crypto !== "undefined" && crypto.subtle) {
     const data = new TextEncoder().encode(text);
@@ -207,6 +209,7 @@ export async function sha256Base64url(text: string): Promise<string> {
   return sha256Base64urlSync(text);
 }
 
+/** Canonicalizes JSON and computes its SHA-256 base64url digest. */
 export async function digestJson(value: JsonValue): Promise<{
   canonical: string;
   digest: string;

package/src/contract_support/mod.ts

@@ -64,6 +64,10 @@ import {
   ContractResourcesSchema,
   ContractSchemaRefSchema,
   ContractStateSchema,
+  type JobKeyConcurrency,
+  JobKeyConcurrencySchema,
+  type JobQueueDepth,
+  JobQueueDepthSchema,
 } from "./protocol.js";
 
 export {
@@ -80,6 +84,7 @@ export {
   ContractJobQueueSchema,
   ContractJobsSchema,
   ContractKvResourceSchema,
+  type ContractResourceBindings,
   ContractResourceBindingsSchema,
   ContractResourcesSchema,
   ContractSchemaRefSchema,
@@ -96,13 +101,19 @@ export {
   CursorQuerySchema,
   type EventConsumerResourceBinding,
   EventConsumerResourceBindingSchema,
-  type EventHeader,
-  EventHeaderSchema,
   type InstalledServiceContract,
   InstalledServiceContractSchema,
   IsoDateSchema,
+  type JobKeyConcurrency,
+  JobKeyConcurrencySchema,
+  type JobQueueDepth,
+  JobQueueDepthSchema,
   type JobsQueueBinding,
   JobsQueueBindingSchema,
+  type JobsQueueDepthBinding,
+  JobsQueueDepthBindingSchema,
+  type JobsQueueKeyConcurrencyBinding,
+  JobsQueueKeyConcurrencyBindingSchema,
   type JobsResourceBinding,
   JobsResourceBindingSchema,
   type KvResourceBinding,
@@ -253,6 +264,7 @@ const ContractOperationSchema = Type.Object({
   input: ContractSchemaRefSchema,
   progress: Type.Optional(ContractSchemaRefSchema),
   output: ContractSchemaRefSchema,
+  errors: Type.Optional(Type.Array(ContractErrorRefSchema)),
   transfer: Type.Optional(OperationTransferSchema),
   capabilities: Type.Optional(OperationCapabilitiesSchema),
   signals: Type.Optional(
@@ -489,9 +501,9 @@ export type ContractRpcMethod = {
   subject: string;
   input: ContractSchemaRef;
   output: ContractSchemaRef;
+  errors?: ContractErrorRef[];
   transfer?: { direction: "receive" };
   capabilities?: { call?: Capability[] };
-  errors?: ContractErrorRef[];
   internal?: boolean;
   docs?: ContractDocs;
 };
@@ -507,6 +519,7 @@ export type ContractOperation = {
   input: ContractSchemaRef;
   progress?: ContractSchemaRef;
   output: ContractSchemaRef;
+  errors?: ContractErrorRef[];
   transfer?: {
     direction: "send";
     store: string;
@@ -556,6 +569,8 @@ export type ContractJobQueueResource = {
   logs?: boolean;
   dlq?: boolean;
   concurrency?: number;
+  keyConcurrency?: JobKeyConcurrency;
+  queue?: JobQueueDepth;
   docs?: ContractDocs;
 };
 
@@ -895,12 +910,14 @@ export type ContractSourceOperationSignal<
 
 export type ContractSourceOperation<
   TSchemaName extends string = string,
+  TErrorName extends string = string,
   TCapability extends string = Capability,
 > = {
   version: `v${number}`;
   input: ContractSchemaRef<TSchemaName>;
   progress?: ContractSchemaRef<TSchemaName>;
   output: ContractSchemaRef<TSchemaName>;
+  errors?: readonly TErrorName[];
   transfer?: {
     direction: "send";
     store: string;
@@ -962,6 +979,17 @@ export type ContractSourceJobQueue<
   logs?: boolean;
   dlq?: boolean;
   concurrency?: number;
+  keyConcurrency?: {
+    key: readonly string[];
+    maxActive?: number;
+    heartbeatIntervalMs?: number;
+    heartbeatTtlMs?: number;
+    stalePolicy?: "fail-stale" | "block";
+  };
+  queue?: {
+    maxQueuedPerKey?: number;
+    whenFull?: "reject" | "coalesce" | "replace-oldest";
+  };
   docs?: ContractDocs;
 };
 
@@ -1511,6 +1539,9 @@ type ProjectedRpc<
 type ProjectedOperations<
   T,
   TSchemas,
+  TId,
+  TCapabilities,
+  TErrors,
 > = T extends Readonly<Record<string, ContractSourceOperation>> ? {
     [K in keyof T]:
       & OperationDesc<
@@ -1518,11 +1549,92 @@ type ProjectedOperations<
         ResolveSchemaFromMap<TSchemas, T[K]["progress"]>,
         ResolveSchemaFromMap<TSchemas, T[K]["output"]>
       >
+      & {
+        subject: ProjectedOperationSubject<K, T[K]>;
+        callerCapabilities: ProjectedOperationCapabilities<
+          T[K],
+          "call",
+          TId,
+          TCapabilities
+        >;
+        observeCapabilities: ProjectedOperationCapabilities<
+          T[K],
+          "observe",
+          TId,
+          TCapabilities
+        >;
+        cancelCapabilities: ProjectedOperationCapabilities<
+          T[K],
+          "cancel",
+          TId,
+          TCapabilities
+        >;
+        controlCapabilities: ProjectedOperationCapabilities<
+          T[K],
+          "control",
+          TId,
+          TCapabilities
+        >;
+      }
+      & {
+        errors?: T[K]["errors"];
+        runtimeErrors?: readonly RuntimeRpcErrorDesc[];
+        declaredErrorTypes?: readonly string[];
+      }
       & (T[K]["transfer"] extends undefined ? {}
-        : { transfer: T[K]["transfer"] });
+        : { transfer: T[K]["transfer"] })
+      & (T[K] extends { cancel: infer TCancel extends boolean }
+        ? { cancel: TCancel }
+        : {});
   }
   : {};
 
+type ProjectedOperationSubject<TKey, TOperation> = TOperation extends {
+  subject: infer TSubject extends string;
+} ? TSubject
+  : TOperation extends { version: infer TVersion extends `v${number}` }
+    ? `operations.${TVersion}.${Extract<TKey, string>}`
+  : string;
+
+type ProjectedCapabilityNamespace<TId extends string> = TId extends
+  `${infer TNamespace}@v${number}` ? TNamespace
+  : TId;
+
+type ProjectedCapability<
+  TCapability,
+  TId,
+  TCapabilities,
+> = TCapability extends string
+  ? TCapability extends PlatformCapability | GlobalCapability ? TCapability
+  : TCapability extends Extract<keyof NonNullable<TCapabilities>, string>
+    ? `${ProjectedCapabilityNamespace<Extract<TId, string>>}::${TCapability}`
+  : TCapability
+  : never;
+
+type ProjectedCapabilityList<
+  TList,
+  TId,
+  TCapabilities,
+> = TList extends readonly string[] ? {
+    readonly [K in keyof TList]: ProjectedCapability<
+      TList[K],
+      TId,
+      TCapabilities
+    >;
+  }
+  : readonly [];
+
+type ProjectedOperationCapabilities<
+  TOperation,
+  TKind extends "call" | "observe" | "cancel" | "control",
+  TId,
+  TCapabilities,
+> = TOperation extends { capabilities: infer TOperationCapabilities }
+  ? TOperationCapabilities extends { [K in TKind]?: infer TList }
+    ? ProjectedCapabilityList<TList, TId, TCapabilities>
+  : readonly []
+  : readonly [];
+
 type ProjectedEvents<
   T,
   TSchemas,
@@ -1546,6 +1658,8 @@ type ProjectedFeeds<
 
 export type OwnedApiFromSource<
   T extends {
+    id?: unknown;
+    capabilities?: unknown;
     schemas?: Readonly<Record<string, TSchema>>;
     errors?: unknown;
     rpc?: unknown;
@@ -1555,7 +1669,13 @@ export type OwnedApiFromSource<
   },
 > = {
   rpc: ProjectedRpc<T["rpc"], T["schemas"], T["errors"]>;
-  operations: ProjectedOperations<T["operations"], T["schemas"]>;
+  operations: ProjectedOperations<
+    T["operations"],
+    T["schemas"],
+    T["id"],
+    T["capabilities"],
+    T["errors"]
+  >;
   events: ProjectedEvents<T["events"], T["schemas"]>;
   feeds: ProjectedFeeds<T["feeds"], T["schemas"]>;
   subjects: {};
@@ -2547,6 +2667,12 @@ function collectReachableSchemaNames(contract: TrellisContractV1): Set<string> {
     for (const signal of Object.values(operation.signals ?? {})) {
       collectSchemaRef(reachableSchemas, signal.input);
     }
+    for (const error of operation.errors ?? []) {
+      const declaration = Object.values(contract.errors ?? {}).find((decl) =>
+        decl.type === error.type
+      );
+      collectSchemaRef(reachableSchemas, declaration?.schema);
+    }
   }
 
   for (const event of Object.values(contract.events ?? {})) {
@@ -2604,6 +2730,26 @@ function projectRpcDeclaredErrors(
   return entries.length > 0 ? Object.fromEntries(entries) : undefined;
 }
 
+function projectOperationDeclaredErrors(
+  contract: TrellisContractV1,
+): Record<string, ContractErrorDecl> | undefined {
+  if (!contract.errors) {
+    return undefined;
+  }
+
+  const declaredErrorTypes = new Set<string>();
+  for (const operation of Object.values(contract.operations ?? {})) {
+    for (const error of operation.errors ?? []) {
+      declaredErrorTypes.add(error.type);
+    }
+  }
+
+  const entries = Object.entries(contract.errors).filter(([, error]) =>
+    declaredErrorTypes.has(error.type)
+  );
+  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+
 function projectDigestResources(
   resources: ContractResources | undefined,
 ): ContractResources | undefined {
@@ -2788,6 +2934,12 @@ function projectDigestOperations(
               },
             }
             : {}),
+          ...(operation.errors
+            ? {
+              errors: sortedUnique(operation.errors.map((error) => error.type))
+                .map((type) => ({ type })),
+            }
+            : {}),
         } satisfies ContractOperation,
       ];
     }),
@@ -3032,6 +3184,9 @@ function operation(operation: ContractOperation): ContractOperation {
         ),
       }
       : {}),
+    ...(operation.errors
+      ? { errors: operation.errors.map((error) => ({ type: error.type })) }
+      : {}),
     ...(operation.cancel !== undefined ? { cancel: operation.cancel } : {}),
     ...(operation.docs ? { docs: contractDocs(operation.docs) } : {}),
   };
@@ -3120,7 +3275,110 @@ function errorDecl(error: ContractErrorDecl): ContractErrorDecl {
   };
 }
 
-function jobQueue(queue: ContractJobQueue): ContractJobQueue {
+type JobKeyConcurrencyLike = {
+  key: readonly string[];
+  maxActive?: number;
+  heartbeatIntervalMs?: number;
+  heartbeatTtlMs?: number;
+  stalePolicy?: "fail-stale" | "block";
+};
+
+type JobQueueDepthLike = {
+  maxQueuedPerKey?: number;
+  whenFull?: "reject" | "coalesce" | "replace-oldest";
+};
+
+function assertValidJsonPointerSyntax(
+  queueType: string,
+  pointer: string,
+): void {
+  if (!pointer.startsWith("/")) {
+    throw new Error(
+      `jobs queue '${queueType}' keyConcurrency.key pointer segment '${pointer}' must start with '/'`,
+    );
+  }
+  for (let index = 0; index < pointer.length; index += 1) {
+    if (pointer[index] !== "~") continue;
+    const escaped = pointer[index + 1];
+    if (escaped !== "0" && escaped !== "1") {
+      throw new Error(
+        `jobs queue '${queueType}' keyConcurrency.key pointer segment '${pointer}' has invalid JSON Pointer escape at offset ${index}; use '~0' for '~' and '~1' for '/'`,
+      );
+    }
+    index += 1;
+  }
+}
+
+function assertValidJobKeyConcurrency(
+  queueType: string,
+  keyConcurrency: JobKeyConcurrencyLike | undefined,
+): void {
+  if (!keyConcurrency) return;
+  if (keyConcurrency.key.length === 0) {
+    throw new Error(
+      `jobs queue '${queueType}' keyConcurrency.key must contain at least one segment`,
+    );
+  }
+  for (const segment of keyConcurrency.key) {
+    if (segment.length === 0) {
+      throw new Error(
+        `jobs queue '${queueType}' keyConcurrency.key segments must be non-empty strings`,
+      );
+    }
+    if (segment.startsWith("/")) {
+      assertValidJsonPointerSyntax(queueType, segment);
+    }
+  }
+  if (
+    keyConcurrency.heartbeatIntervalMs !== undefined &&
+    keyConcurrency.heartbeatTtlMs !== undefined &&
+    keyConcurrency.heartbeatTtlMs <= keyConcurrency.heartbeatIntervalMs
+  ) {
+    throw new Error(
+      `jobs queue '${queueType}' keyConcurrency.heartbeatTtlMs must exceed heartbeatIntervalMs`,
+    );
+  }
+}
+
+function jobKeyConcurrency(
+  queueType: string,
+  keyConcurrency: JobKeyConcurrencyLike | undefined,
+): JobKeyConcurrency | undefined {
+  assertValidJobKeyConcurrency(queueType, keyConcurrency);
+  if (!keyConcurrency) return undefined;
+  return {
+    key: [...keyConcurrency.key],
+    ...(keyConcurrency.maxActive !== undefined
+      ? { maxActive: keyConcurrency.maxActive }
+      : {}),
+    ...(keyConcurrency.heartbeatIntervalMs !== undefined
+      ? { heartbeatIntervalMs: keyConcurrency.heartbeatIntervalMs }
+      : {}),
+    ...(keyConcurrency.heartbeatTtlMs !== undefined
+      ? { heartbeatTtlMs: keyConcurrency.heartbeatTtlMs }
+      : {}),
+    ...(keyConcurrency.stalePolicy !== undefined
+      ? { stalePolicy: keyConcurrency.stalePolicy }
+      : {}),
+  };
+}
+
+function jobQueueDepth(
+  queue: JobQueueDepthLike | undefined,
+): JobQueueDepth | undefined {
+  if (!queue) return undefined;
+  return {
+    ...(queue.maxQueuedPerKey !== undefined
+      ? { maxQueuedPerKey: queue.maxQueuedPerKey }
+      : {}),
+    ...(queue.whenFull !== undefined ? { whenFull: queue.whenFull } : {}),
+  };
+}
+
+function jobQueue(
+  queueType: string,
+  queue: ContractJobQueue,
+): ContractJobQueue {
   return {
     payload: schemaRef(queue.payload),
     ...(queue.result ? { result: schemaRef(queue.result) } : {}),
@@ -3136,6 +3394,10 @@ function jobQueue(queue: ContractJobQueue): ContractJobQueue {
     ...(queue.concurrency !== undefined
       ? { concurrency: queue.concurrency }
       : {}),
+    ...(queue.keyConcurrency
+      ? { keyConcurrency: jobKeyConcurrency(queueType, queue.keyConcurrency) }
+      : {}),
+    ...(queue.queue ? { queue: jobQueueDepth(queue.queue) } : {}),
     ...(queue.docs ? { docs: contractDocs(queue.docs) } : {}),
   };
 }
@@ -3209,7 +3471,16 @@ export function normalizeContractManifest(
       : {}),
     ...(contract.events ? { events: mapValues(contract.events, event) } : {}),
     ...(contract.feeds ? { feeds: mapValues(contract.feeds, feed) } : {}),
-    ...(contract.jobs ? { jobs: mapValues(contract.jobs, jobQueue) } : {}),
+    ...(contract.jobs
+      ? {
+        jobs: Object.fromEntries(
+          Object.entries(contract.jobs).map(([queueType, queue]) => [
+            queueType,
+            jobQueue(queueType, queue),
+          ]),
+        ),
+      }
+      : {}),
     ...(contract.eventConsumers
       ? {
         eventConsumers: mapValues(
@@ -3271,7 +3542,12 @@ export function projectContractDigestManifest(
   contract: TrellisContractV1,
 ): JsonValue {
   const schemas = projectReachableSchemas(contract);
-  const errors = projectRpcDeclaredErrors(contract);
+  const rpcDeclaredErrors = projectRpcDeclaredErrors(contract);
+  const operationDeclaredErrors = projectOperationDeclaredErrors(contract);
+  const combinedErrors = { ...rpcDeclaredErrors, ...operationDeclaredErrors };
+  const errors = Object.keys(combinedErrors).length > 0
+    ? combinedErrors
+    : undefined;
   const state = projectDigestState(contract.state);
   const resources = projectDigestResources(contract.resources);
   const jobs = projectDigestJobs(contract.jobs);
@@ -3412,6 +3688,12 @@ function emitJobs(
         ...(queue.concurrency !== undefined
           ? { concurrency: queue.concurrency }
           : {}),
+        ...(queue.keyConcurrency
+          ? {
+            keyConcurrency: jobKeyConcurrency(queueType, queue.keyConcurrency),
+          }
+          : {}),
+        ...(queue.queue ? { queue: jobQueueDepth(queue.queue) } : {}),
         ...(queue.docs ? { docs: contractDocs(queue.docs) } : {}),
       } satisfies ContractJobQueue,
     ]),
@@ -3744,6 +4026,13 @@ function emitContract(source: TrellisContractSource): TrellisContractV1 {
         if (operation.docs) {
           emitted.docs = contractDocs(operation.docs);
         }
+        if (operation.errors && operation.errors.length > 0) {
+          emitted.errors = sortedUnique(
+            operation.errors.map((errorName) =>
+              source.errors?.[errorName]?.type ?? errorName
+            ),
+          ).map((type) => ({ type }));
+        }
         return [name, emitted];
       }),
     )
@@ -4018,6 +4307,14 @@ function buildOwnedApi(source: TrellisContractSource): ApiShape {
           `operation '${name}' control capabilities`,
         ) ?? [],
         cancel: operation.cancel,
+        errors: operation.errors,
+        declaredErrorTypes: operation.errors?.map((errorName) =>
+          source.errors?.[errorName]?.type ?? errorName
+        ),
+        runtimeErrors: operation.errors?.flatMap((errorName) => {
+          const runtimeError = localRuntimeErrors[errorName];
+          return runtimeError ? [runtimeError] : [];
+        }),
       },
     ]),
   ) as Record<string, OperationDesc>;
@@ -4350,6 +4647,73 @@ export function defineError<
   return DefinedErrorImpl;
 }
 
+/**
+ * Hints for a single schema validation keyword failure.
+ *
+ * Provides per-keyway UX metadata that a UI can surface when a field-level
+ * validation error occurs for this schema node.
+ */
+export type TrellisValidationIssueHint = {
+  code: string;
+  message: string;
+  note?: string;
+  label?: string;
+  i18nKey?: string;
+  severity?: "error" | "warning" | "info";
+};
+
+/**
+ * Extension metadata attached to a TypeBox schema node via
+ * `withTrellisValidation`.
+ *
+ * Carries the label, note, uiPath, and per-keyword issue hints that the
+ * runtime uses to produce structured field-level validation errors.
+ */
+export type TrellisValidationExtension = {
+  label?: string;
+  note?: string;
+  uiPath?: string;
+  issues?: Record<string, TrellisValidationIssueHint>;
+};
+
+/**
+ * Attaches Trellis validation UX metadata to a TypeBox schema node.
+ *
+ * When a request fails schema validation before handler dispatch, the metadata
+ * is used to produce a `SchemaValidationError` with stable field-level issue
+ * information that UIs can use without needing service-specific error handling.
+ *
+ * @template T The schema type.
+ * @param schema The TypeBox schema to annotate.
+ * @param extension The validation extension with labels, notes, and per-keyword issue hints.
+ * @returns The same schema type with `x-trellis-validation` attached.
+ *
+ * @example
+ * ```ts
+ * const MySchema = Type.Object({
+ *   name: withTrellisValidation(Type.String({ minLength: 1 }), {
+ *     label: "Name",
+ *     issues: {
+ *       minLength: {
+ *         code: "my.name.required",
+ *         message: "Enter a name.",
+ *       },
+ *     },
+ *   }),
+ * });
+ * ```
+ */
+export function withTrellisValidation<
+  T extends TSchema,
+>(
+  schema: T,
+  extension: TrellisValidationExtension,
+): T {
+  const cloned = { ...schema } as Record<string, unknown>;
+  cloned["x-trellis-validation"] = extension;
+  return cloned as T;
+}
+
 function createUseHelper<
   TContractId extends string,
   TOwnedApi extends TrellisApiLike,
@@ -5460,4 +5824,11 @@ export type {
   SerializableErrorData,
   TrellisAPI,
 };
-export { canonicalizeJson, digestJson, isJsonValue, schema, unwrapSchema };
+export {
+  canonicalizeJson,
+  digestJson,
+  isJsonValue,
+  schema,
+  sha256Base64urlSync,
+  unwrapSchema,
+};

package/src/contract_support/protocol.ts

@@ -81,6 +81,30 @@ export const ContractStateSchema = Type.Record(
 
 export type ContractState = Static<typeof ContractStateSchema>;
 
+export const JobKeyConcurrencySchema = Type.Object({
+  key: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+  maxActive: Type.Optional(Type.Integer({ minimum: 1 })),
+  heartbeatIntervalMs: Type.Optional(Type.Integer({ minimum: 1 })),
+  heartbeatTtlMs: Type.Optional(Type.Integer({ minimum: 1 })),
+  stalePolicy: Type.Optional(Type.Union([
+    Type.Literal("fail-stale"),
+    Type.Literal("block"),
+  ])),
+});
+
+export type JobKeyConcurrency = Static<typeof JobKeyConcurrencySchema>;
+
+export const JobQueueDepthSchema = Type.Object({
+  maxQueuedPerKey: Type.Optional(Type.Integer({ minimum: 0 })),
+  whenFull: Type.Optional(Type.Union([
+    Type.Literal("reject"),
+    Type.Literal("coalesce"),
+    Type.Literal("replace-oldest"),
+  ])),
+});
+
+export type JobQueueDepth = Static<typeof JobQueueDepthSchema>;
+
 export const ContractJobQueueSchema = Type.Object({
   payload: ContractSchemaRefSchema,
   result: Type.Optional(ContractSchemaRefSchema),
@@ -92,6 +116,8 @@ export const ContractJobQueueSchema = Type.Object({
   logs: Type.Optional(Type.Boolean()),
   dlq: Type.Optional(Type.Boolean()),
   concurrency: Type.Optional(Type.Integer({ minimum: 1 })),
+  keyConcurrency: Type.Optional(JobKeyConcurrencySchema),
+  queue: Type.Optional(JobQueueDepthSchema),
   docs: Type.Optional(ContractDocsSchema),
 });
 
@@ -178,6 +204,34 @@ export const StoreResourceBindingSchema = Type.Object({
 
 export type StoreResourceBinding = Static<typeof StoreResourceBindingSchema>;
 
+export const JobsQueueKeyConcurrencyBindingSchema = Type.Object({
+  key: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+  maxActive: Type.Integer({ minimum: 1 }),
+  heartbeatIntervalMs: Type.Integer({ minimum: 1 }),
+  heartbeatTtlMs: Type.Integer({ minimum: 1 }),
+  stalePolicy: Type.Union([
+    Type.Literal("fail-stale"),
+    Type.Literal("block"),
+  ]),
+});
+
+export type JobsQueueKeyConcurrencyBinding = Static<
+  typeof JobsQueueKeyConcurrencyBindingSchema
+>;
+
+export const JobsQueueDepthBindingSchema = Type.Object({
+  maxQueuedPerKey: Type.Integer({ minimum: 0 }),
+  whenFull: Type.Union([
+    Type.Literal("reject"),
+    Type.Literal("coalesce"),
+    Type.Literal("replace-oldest"),
+  ]),
+});
+
+export type JobsQueueDepthBinding = Static<
+  typeof JobsQueueDepthBindingSchema
+>;
+
 export const JobsQueueBindingSchema = Type.Object({
   queueType: Type.String({ minLength: 1 }),
   publishPrefix: Type.String({ minLength: 1 }),
@@ -193,6 +247,8 @@ export const JobsQueueBindingSchema = Type.Object({
   logs: Type.Boolean(),
   dlq: Type.Boolean(),
   concurrency: Type.Integer({ minimum: 1 }),
+  keyConcurrency: Type.Optional(JobsQueueKeyConcurrencyBindingSchema),
+  queue: Type.Optional(JobsQueueDepthBindingSchema),
 });
 
 export type JobsQueueBinding = Static<typeof JobsQueueBindingSchema>;
@@ -257,15 +313,6 @@ export const IsoDateSchema = Type.Codec(
   .Decode((value: string) => parseIsoDate(value))
   .Encode((value: Date) => formatIsoDate(value));
 
-export const EventHeaderSchema = Type.Object({
-  header: Type.Object({
-    id: Type.String(),
-    time: IsoDateSchema,
-  }),
-});
-
-export type EventHeader = Static<typeof EventHeaderSchema>;
-
 /** Schema for a bounded pagination request. */
 export const PageRequestSchema = Type.Object({
   offset: Type.Optional(Type.Integer({ minimum: 0 })),
@@ -347,7 +394,7 @@ export function buildPageResponse<T>(
 /** Schema for a cursor pagination query. */
 export const CursorQuerySchema = Type.Object({
   cursor: Type.Optional(Type.String({ minLength: 1 })),
-  limit: Type.Optional(Type.Integer({ minimum: 0 })),
+  limit: Type.Optional(Type.Integer({ minimum: 0, maximum: 500 })),
 });
 
 /** Cursor pagination query. */