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

package/src/sdk/_generated/jobs/types.ts

@@ -1,19 +1,35 @@
 // Generated from ./generated/contracts/manifests/trellis.jobs@v1.json
-import type { RpcHandlerFn } from "../../../index.js";
-import type { API } from "./api.js";
+import type {
+  BaseError,
+  HandlerTrellis,
+  Result,
+  RpcHandlerContext,
+  TrellisErrorInstance,
+} from "../../../index.js";
+
+import type { Api } from "./api.js";
 
 import { type SerializableErrorData, TrellisError } from "../../../index.js";
 
 import { NotFoundErrorDataSchema } from "./schemas.js";
 
+export type HandlerClient = HandlerTrellis<Api>;
+
 export const CONTRACT_ID = "trellis.jobs@v1" as const;
 export const CONTRACT_DIGEST =
-  "jSB8nKGOQqIxdFDdUqO-gOTt3Dijg--SOXJtJ1ChpoY" as const;
+  "xDigtrlrF3n3ZNgHVdwDJFcwi0PEJBiDyBG6FnzFzM8" as const;
 
 export type JobsCancelInput = { id: string };
 export type JobsCancelOutput = {
   job: {
     completedAt?: string;
+    concurrency?: {
+      heartbeatAt?: string;
+      key: string;
+      keyHash: string;
+      leaseExpiresAt?: string;
+      staleTakeoverCount?: number;
+    };
     context: {
       requestId: string;
       traceId: string;
@@ -35,6 +51,12 @@ export type JobsCancelOutput = {
       step?: string;
       total?: number;
     };
+    queuePolicy?: {
+      existingJobId?: string;
+      outcome: string;
+      reason?: string;
+      replacedJobId?: string;
+    };
     result?: unknown;
     service: string;
     startedAt?: string;
@@ -58,6 +80,13 @@ export type JobsDismissDLQInput = { id: string };
 export type JobsDismissDLQOutput = {
   job: {
     completedAt?: string;
+    concurrency?: {
+      heartbeatAt?: string;
+      key: string;
+      keyHash: string;
+      leaseExpiresAt?: string;
+      staleTakeoverCount?: number;
+    };
     context: {
       requestId: string;
       traceId: string;
@@ -79,6 +108,12 @@ export type JobsDismissDLQOutput = {
       step?: string;
       total?: number;
     };
+    queuePolicy?: {
+      existingJobId?: string;
+      outcome: string;
+      reason?: string;
+      replacedJobId?: string;
+    };
     result?: unknown;
     service: string;
     startedAt?: string;
@@ -102,6 +137,13 @@ export type JobsGetInput = { id: string };
 export type JobsGetOutput = {
   job: {
     completedAt?: string;
+    concurrency?: {
+      heartbeatAt?: string;
+      key: string;
+      keyHash: string;
+      leaseExpiresAt?: string;
+      staleTakeoverCount?: number;
+    };
     context: {
       requestId: string;
       traceId: string;
@@ -123,6 +165,12 @@ export type JobsGetOutput = {
       step?: string;
       total?: number;
     };
+    queuePolicy?: {
+      existingJobId?: string;
+      outcome: string;
+      reason?: string;
+      replacedJobId?: string;
+    };
     result?: unknown;
     service: string;
     startedAt?: string;
@@ -142,6 +190,28 @@ export type JobsGetOutput = {
   };
 };
 
+export type JobsGetKeyInput = { key: string; service: string; type: string };
+export type JobsGetKeyOutput = {
+  active: Array<
+    {
+      heartbeatAgeMs: number;
+      heartbeatAt: string;
+      instanceId: string;
+      jobId: string;
+      leaseExpiresAt: string;
+      startedAt: string;
+    }
+  >;
+  key: string;
+  keyHash: string;
+  latestPolicyReason?: string;
+  queued: Array<{ createdAt: string; jobId: string }>;
+  queuedDepth: number;
+  service: string;
+  staleTakeoverCount: number;
+  type: string;
+};
+
 export type JobsHealthInput = {};
 export type JobsHealthOutput = {
   checks: Array<{ [k: string]: unknown }>;
@@ -175,6 +245,13 @@ export type JobsListOutput = {
   entries: Array<
     {
       completedAt?: string;
+      concurrency?: {
+        heartbeatAt?: string;
+        key: string;
+        keyHash: string;
+        leaseExpiresAt?: string;
+        staleTakeoverCount?: number;
+      };
       context: {
         requestId: string;
         traceId: string;
@@ -196,6 +273,12 @@ export type JobsListOutput = {
         step?: string;
         total?: number;
       };
+      queuePolicy?: {
+        existingJobId?: string;
+        outcome: string;
+        reason?: string;
+        replacedJobId?: string;
+      };
       result?: unknown;
       service: string;
       startedAt?: string;
@@ -231,6 +314,13 @@ export type JobsListDLQOutput = {
   entries: Array<
     {
       completedAt?: string;
+      concurrency?: {
+        heartbeatAt?: string;
+        key: string;
+        keyHash: string;
+        leaseExpiresAt?: string;
+        staleTakeoverCount?: number;
+      };
       context: {
         requestId: string;
         traceId: string;
@@ -252,6 +342,12 @@ export type JobsListDLQOutput = {
         step?: string;
         total?: number;
       };
+      queuePolicy?: {
+        existingJobId?: string;
+        outcome: string;
+        reason?: string;
+        replacedJobId?: string;
+      };
       result?: unknown;
       service: string;
       startedAt?: string;
@@ -303,6 +399,13 @@ export type JobsReplayDLQInput = { id: string };
 export type JobsReplayDLQOutput = {
   job: {
     completedAt?: string;
+    concurrency?: {
+      heartbeatAt?: string;
+      key: string;
+      keyHash: string;
+      leaseExpiresAt?: string;
+      staleTakeoverCount?: number;
+    };
     context: {
       requestId: string;
       traceId: string;
@@ -324,6 +427,12 @@ export type JobsReplayDLQOutput = {
       step?: string;
       total?: number;
     };
+    queuePolicy?: {
+      existingJobId?: string;
+      outcome: string;
+      reason?: string;
+      replacedJobId?: string;
+    };
     result?: unknown;
     service: string;
     startedAt?: string;
@@ -347,6 +456,13 @@ export type JobsRetryInput = { id: string };
 export type JobsRetryOutput = {
   job: {
     completedAt?: string;
+    concurrency?: {
+      heartbeatAt?: string;
+      key: string;
+      keyHash: string;
+      leaseExpiresAt?: string;
+      staleTakeoverCount?: number;
+    };
     context: {
       requestId: string;
       traceId: string;
@@ -368,6 +484,12 @@ export type JobsRetryOutput = {
       step?: string;
       total?: number;
     };
+    queuePolicy?: {
+      existingJobId?: string;
+      outcome: string;
+      reason?: string;
+      replacedJobId?: string;
+    };
     result?: unknown;
     service: string;
     startedAt?: string;
@@ -425,6 +547,7 @@ export interface RpcMap {
     output: JobsDismissDLQOutput;
   };
   "Jobs.Get": { input: JobsGetInput; output: JobsGetOutput };
+  "Jobs.GetKey": { input: JobsGetKeyInput; output: JobsGetKeyOutput };
   "Jobs.Health": { input: JobsHealthInput; output: JobsHealthOutput };
   "Jobs.List": { input: JobsListInput; output: JobsListOutput };
   "Jobs.ListDLQ": { input: JobsListDLQInput; output: JobsListDLQOutput };
@@ -436,24 +559,135 @@ export interface RpcMap {
   "Jobs.Retry": { input: JobsRetryInput; output: JobsRetryOutput };
 }
 
-export type JobsCancelHandler = RpcHandlerFn<typeof API.owned, "Jobs.Cancel">;
-export type JobsDismissDLQHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Jobs.DismissDLQ"
+export type JobsCancelHandlerError =
+  | TrellisErrorInstance
+  | BaseError<NotFoundErrorData>;
+export type JobsCancelHandlerResult = Result<
+  JobsCancelOutput,
+  JobsCancelHandlerError
+>;
+export type JobsCancelHandler = (
+  args: {
+    input: JobsCancelInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => JobsCancelHandlerResult | Promise<JobsCancelHandlerResult>;
+export type JobsDismissDLQHandlerError =
+  | TrellisErrorInstance
+  | BaseError<NotFoundErrorData>;
+export type JobsDismissDLQHandlerResult = Result<
+  JobsDismissDLQOutput,
+  JobsDismissDLQHandlerError
 >;
-export type JobsGetHandler = RpcHandlerFn<typeof API.owned, "Jobs.Get">;
-export type JobsHealthHandler = RpcHandlerFn<typeof API.owned, "Jobs.Health">;
-export type JobsListHandler = RpcHandlerFn<typeof API.owned, "Jobs.List">;
-export type JobsListDLQHandler = RpcHandlerFn<typeof API.owned, "Jobs.ListDLQ">;
-export type JobsListServicesHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Jobs.ListServices"
+export type JobsDismissDLQHandler = (
+  args: {
+    input: JobsDismissDLQInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => JobsDismissDLQHandlerResult | Promise<JobsDismissDLQHandlerResult>;
+export type JobsGetHandlerError =
+  | TrellisErrorInstance
+  | BaseError<NotFoundErrorData>;
+export type JobsGetHandlerResult = Result<JobsGetOutput, JobsGetHandlerError>;
+export type JobsGetHandler = (
+  args: {
+    input: JobsGetInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => JobsGetHandlerResult | Promise<JobsGetHandlerResult>;
+export type JobsGetKeyHandlerError =
+  | TrellisErrorInstance
+  | BaseError<NotFoundErrorData>;
+export type JobsGetKeyHandlerResult = Result<
+  JobsGetKeyOutput,
+  JobsGetKeyHandlerError
+>;
+export type JobsGetKeyHandler = (
+  args: {
+    input: JobsGetKeyInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => JobsGetKeyHandlerResult | Promise<JobsGetKeyHandlerResult>;
+export type JobsHealthHandlerError = TrellisErrorInstance;
+export type JobsHealthHandlerResult = Result<
+  JobsHealthOutput,
+  JobsHealthHandlerError
+>;
+export type JobsHealthHandler = (
+  args: {
+    input: JobsHealthInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => JobsHealthHandlerResult | Promise<JobsHealthHandlerResult>;
+export type JobsListHandlerError = TrellisErrorInstance;
+export type JobsListHandlerResult = Result<
+  JobsListOutput,
+  JobsListHandlerError
+>;
+export type JobsListHandler = (
+  args: {
+    input: JobsListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => JobsListHandlerResult | Promise<JobsListHandlerResult>;
+export type JobsListDLQHandlerError = TrellisErrorInstance;
+export type JobsListDLQHandlerResult = Result<
+  JobsListDLQOutput,
+  JobsListDLQHandlerError
+>;
+export type JobsListDLQHandler = (
+  args: {
+    input: JobsListDLQInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => JobsListDLQHandlerResult | Promise<JobsListDLQHandlerResult>;
+export type JobsListServicesHandlerError = TrellisErrorInstance;
+export type JobsListServicesHandlerResult = Result<
+  JobsListServicesOutput,
+  JobsListServicesHandlerError
+>;
+export type JobsListServicesHandler = (
+  args: {
+    input: JobsListServicesInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => JobsListServicesHandlerResult | Promise<JobsListServicesHandlerResult>;
+export type JobsReplayDLQHandlerError =
+  | TrellisErrorInstance
+  | BaseError<NotFoundErrorData>;
+export type JobsReplayDLQHandlerResult = Result<
+  JobsReplayDLQOutput,
+  JobsReplayDLQHandlerError
 >;
-export type JobsReplayDLQHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Jobs.ReplayDLQ"
+export type JobsReplayDLQHandler = (
+  args: {
+    input: JobsReplayDLQInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => JobsReplayDLQHandlerResult | Promise<JobsReplayDLQHandlerResult>;
+export type JobsRetryHandlerError =
+  | TrellisErrorInstance
+  | BaseError<NotFoundErrorData>;
+export type JobsRetryHandlerResult = Result<
+  JobsRetryOutput,
+  JobsRetryHandlerError
 >;
-export type JobsRetryHandler = RpcHandlerFn<typeof API.owned, "Jobs.Retry">;
+export type JobsRetryHandler = (
+  args: {
+    input: JobsRetryInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => JobsRetryHandlerResult | Promise<JobsRetryHandlerResult>;
 
 export interface EventMap {
 }

package/src/sdk/_generated/state/api.ts

@@ -4,6 +4,25 @@ import { OWNED_API as HealthApi } from "../health/mod.js";
 
 export { OWNED_API };
 
+type __TrellisGeneratedOptionalOperationProgress<TDesc> = TDesc extends
+  { progress: infer TProgress } ? { progress?: TProgress }
+  : { progress?: undefined };
+type __TrellisGeneratedOptionalOperationOutput<TDesc> = TDesc extends
+  { output: infer TOutput } ? { output?: TOutput }
+  : { output?: undefined };
+type __TrellisGeneratedOptionalOperationIO<TDesc> = TDesc extends
+  { input: infer TInput } ?
+    & Omit<TDesc, "input" | "progress" | "output">
+    & {
+      input: TInput;
+    }
+    & __TrellisGeneratedOptionalOperationProgress<TDesc>
+    & __TrellisGeneratedOptionalOperationOutput<TDesc>
+  : TDesc;
+type __TrellisGeneratedOperationApi<TApi> = {
+  readonly [K in keyof TApi]: __TrellisGeneratedOptionalOperationIO<TApi[K]>;
+};
+
 export type UsedApi = {
   rpc: {};
   operations: {};
@@ -26,7 +45,9 @@ export const USED_API: UsedApi = {
   subjects: {},
 };
 
-export type OwnedApi = typeof OWNED_API;
+export type OwnedApi = Omit<typeof OWNED_API, "operations"> & {
+  operations: __TrellisGeneratedOperationApi<typeof OWNED_API["operations"]>;
+};
 export type Api = {
   rpc: OwnedApi["rpc"] & UsedApi["rpc"];
   operations: OwnedApi["operations"] & UsedApi["operations"];
@@ -35,9 +56,12 @@ export type Api = {
   subjects: OwnedApi["subjects"] & UsedApi["subjects"];
 };
 
-export const API = {
+export type ApiViews = {
+  owned: OwnedApi;
+  used: UsedApi;
+};
+
+export const API: ApiViews = {
   owned: OWNED_API,
   used: USED_API,
-} as const;
-
-export type ApiViews = typeof API;
+};

package/src/sdk/_generated/state/client.ts

@@ -15,13 +15,11 @@ import type {
   OperationRef,
   OperationRefData,
   OperationRuntimeHandle,
-  OperationTransferHandle,
   PreparedTrellisEvent,
   ReceiveTransferGrant,
   ReceiveTransferHandle,
   RequestOpts,
   Result,
-  RpcHandlerContext,
   SendTransferGrant,
   SendTransferHandle,
   TerminalOperation,
@@ -35,8 +33,6 @@ import type { API, Api } from "./api.js";
 import type * as Types from "./types.js";
 import type * as HealthSdk from "../health/mod.js";
 
-type WithDeps<TDeps> = [TDeps] extends [undefined] ? {} : { deps: TDeps };
-
 type EventCallback<TMessage> = {
   bivarianceHack(
     message: TMessage,
@@ -44,46 +40,10 @@ type EventCallback<TMessage> = {
   ): MaybeAsync<void, BaseError>;
 }["bivarianceHack"];
 
-type ServiceEventHandler<TEvent, TDeps = undefined> = (
-  args:
-    & { event: TEvent; context: EventListenerContext; client: HandlerClient }
-    & WithDeps<TDeps>,
+type DependencyServiceEventHandler<TEvent> = (
+  args: { event: TEvent; context: EventListenerContext; client: HandlerClient },
 ) => MaybeAsync<void, BaseError>;
 
-type RpcHandler<TInput, TOutput, TDeps = undefined> = (
-  args:
-    & { input: TInput; context: RpcHandlerContext; client: HandlerClient }
-    & WithDeps<TDeps>,
-) => MaybeAsync<TOutput, BaseError>;
-
-type FeedHandler<TInput, TEvent, TDeps = undefined> = (
-  context: {
-    input: TInput;
-    caller: unknown;
-    signal: AbortSignal;
-    emit(event: TEvent): AsyncResult<void, ValidationError | UnexpectedError>;
-    client: HandlerClient;
-  } & WithDeps<TDeps>,
-) => unknown | Promise<unknown>;
-
-type OperationHandler<
-  TInput,
-  TProgress,
-  TOutput,
-  TTransfer,
-  TDeps = undefined,
-> = (
-  context:
-    & {
-      input: TInput;
-      op: OperationRuntimeHandle<TProgress, TOutput>;
-      caller: unknown;
-      client: HandlerClient;
-    }
-    & TTransfer
-    & WithDeps<TDeps>,
-) => unknown | Promise<unknown>;
-
 export type TrellisStateState = {};
 
 export interface TrellisStateClient {
@@ -131,12 +91,12 @@ export interface TrellisStateClient {
     readonly health: {
       heartbeat: {
         publish(
-          event: Omit<HealthSdk.HealthHeartbeatEvent, "header">,
+          event: HealthSdk.HealthHeartbeatEvent,
         ): AsyncResult<void, ValidationError | UnexpectedError>;
         prepare(
-          event: Omit<HealthSdk.HealthHeartbeatEvent, "header">,
+          event: HealthSdk.HealthHeartbeatEvent,
         ): Result<
-          PreparedTrellisEvent<Omit<HealthSdk.HealthHeartbeatEvent, "header">>,
+          PreparedTrellisEvent<HealthSdk.HealthHeartbeatEvent>,
           ValidationError | UnexpectedError
         >;
         listen(
@@ -154,29 +114,22 @@ export interface TrellisStateClient {
 
 export interface Service extends TrellisStateClient {
   readonly handle: ServiceHandle;
-  with<TDeps>(deps: TDeps): ServiceWithDeps<TDeps>;
 }
 
-export type ServiceWithDeps<TDeps> = Omit<TrellisStateClient, "event"> & {
-  readonly event: ServiceEventSurface<TDeps>;
-  readonly handle: ServiceHandle<TDeps>;
-  with<TNextDeps>(deps: TNextDeps): ServiceWithDeps<TNextDeps>;
-};
-
-export interface ServiceEventSurface<TDeps> {
+export interface ServiceEventSurface {
   readonly health: {
     heartbeat: {
       publish(
-        event: Omit<HealthSdk.HealthHeartbeatEvent, "header">,
+        event: HealthSdk.HealthHeartbeatEvent,
       ): AsyncResult<void, ValidationError | UnexpectedError>;
       prepare(
-        event: Omit<HealthSdk.HealthHeartbeatEvent, "header">,
+        event: HealthSdk.HealthHeartbeatEvent,
       ): Result<
-        PreparedTrellisEvent<Omit<HealthSdk.HealthHeartbeatEvent, "header">>,
+        PreparedTrellisEvent<HealthSdk.HealthHeartbeatEvent>,
         ValidationError | UnexpectedError
       >;
       listen(
-        handler: ServiceEventHandler<HealthSdk.HealthHeartbeatEvent, TDeps>,
+        handler: DependencyServiceEventHandler<HealthSdk.HealthHeartbeatEvent>,
         subjectData?: Record<string, unknown>,
         opts?: EventOpts,
       ): AsyncResult<void, ValidationError | UnexpectedError>;
@@ -184,46 +137,16 @@ export interface ServiceEventSurface<TDeps> {
   };
 }
 
-export interface ServiceHandle<TDeps = undefined> {
+export interface ServiceHandle {
   readonly rpc: {
     readonly state: {
-      adminDelete(
-        handler: RpcHandler<
-          Types.StateAdminDeleteInput,
-          Types.StateAdminDeleteOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      adminGet(
-        handler: RpcHandler<
-          Types.StateAdminGetInput,
-          Types.StateAdminGetOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      adminList(
-        handler: RpcHandler<
-          Types.StateAdminListInput,
-          Types.StateAdminListOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      delete(
-        handler: RpcHandler<
-          Types.StateDeleteInput,
-          Types.StateDeleteOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      get(
-        handler: RpcHandler<Types.StateGetInput, Types.StateGetOutput, TDeps>,
-      ): Promise<void>;
-      list(
-        handler: RpcHandler<Types.StateListInput, Types.StateListOutput, TDeps>,
-      ): Promise<void>;
-      put(
-        handler: RpcHandler<Types.StatePutInput, Types.StatePutOutput, TDeps>,
-      ): Promise<void>;
+      adminDelete(handler: Types.StateAdminDeleteHandler): Promise<void>;
+      adminGet(handler: Types.StateAdminGetHandler): Promise<void>;
+      adminList(handler: Types.StateAdminListHandler): Promise<void>;
+      delete(handler: Types.StateDeleteHandler): Promise<void>;
+      get(handler: Types.StateGetHandler): Promise<void>;
+      list(handler: Types.StateListHandler): Promise<void>;
+      put(handler: Types.StatePutHandler): Promise<void>;
     };
   };
   readonly feed: {};

package/src/sdk/_generated/state/mod.ts

@@ -8,7 +8,6 @@ export type {
   Service,
   ServiceEventSurface,
   ServiceHandle,
-  ServiceWithDeps,
   TrellisStateClient,
   TrellisStateState,
 } from "./client.js";

package/src/sdk/_generated/state/owned_api.ts

@@ -27,7 +27,7 @@ export const OWNED_API = {
       output: schema<Types.StateAdminDeleteOutput>(
         StateAdminDeleteResponseSchema,
       ),
-      callerCapabilities: ["admin"],
+      callerCapabilities: ["admin"] as const,
       errors: ["AuthError", "UnexpectedError", "ValidationError"] as const,
       declaredErrorTypes: [
         "AuthError",
@@ -39,7 +39,7 @@ export const OWNED_API = {
       subject: "rpc.v1.State.Admin.Get",
       input: schema<Types.StateAdminGetInput>(StateAdminGetRequestSchema),
       output: schema<Types.StateAdminGetOutput>(StateAdminGetResponseSchema),
-      callerCapabilities: ["admin"],
+      callerCapabilities: ["admin"] as const,
       errors: ["AuthError", "UnexpectedError", "ValidationError"] as const,
       declaredErrorTypes: [
         "AuthError",
@@ -51,7 +51,7 @@ export const OWNED_API = {
       subject: "rpc.v1.State.Admin.List",
       input: schema<Types.StateAdminListInput>(StateAdminListRequestSchema),
       output: schema<Types.StateAdminListOutput>(StateAdminListResponseSchema),
-      callerCapabilities: ["admin"],
+      callerCapabilities: ["admin"] as const,
       errors: ["AuthError", "UnexpectedError", "ValidationError"] as const,
       declaredErrorTypes: [
         "AuthError",
@@ -63,7 +63,7 @@ export const OWNED_API = {
       subject: "rpc.v1.State.Delete",
       input: schema<Types.StateDeleteInput>(StateDeleteRequestSchema),
       output: schema<Types.StateDeleteOutput>(StateDeleteResponseSchema),
-      callerCapabilities: [],
+      callerCapabilities: [] as const,
       errors: ["AuthError", "UnexpectedError", "ValidationError"] as const,
       declaredErrorTypes: [
         "AuthError",
@@ -75,7 +75,7 @@ export const OWNED_API = {
       subject: "rpc.v1.State.Get",
       input: schema<Types.StateGetInput>(StateGetRequestSchema),
       output: schema<Types.StateGetOutput>(StateGetResponseSchema),
-      callerCapabilities: [],
+      callerCapabilities: [] as const,
       errors: ["AuthError", "UnexpectedError", "ValidationError"] as const,
       declaredErrorTypes: [
         "AuthError",
@@ -87,7 +87,7 @@ export const OWNED_API = {
       subject: "rpc.v1.State.List",
       input: schema<Types.StateListInput>(StateListRequestSchema),
       output: schema<Types.StateListOutput>(StateListResponseSchema),
-      callerCapabilities: [],
+      callerCapabilities: [] as const,
       errors: ["AuthError", "UnexpectedError", "ValidationError"] as const,
       declaredErrorTypes: [
         "AuthError",
@@ -99,7 +99,7 @@ export const OWNED_API = {
       subject: "rpc.v1.State.Put",
       input: schema<Types.StatePutInput>(StatePutRequestSchema),
       output: schema<Types.StatePutOutput>(StatePutResponseSchema),
-      callerCapabilities: [],
+      callerCapabilities: [] as const,
       errors: ["AuthError", "UnexpectedError", "ValidationError"] as const,
       declaredErrorTypes: [
         "AuthError",