@qlever-llc/trellis 0.8.4 → 0.9.0-rc.2

package/esm/npm/src/contract_support/mod.d.ts

@@ -1,18 +1,253 @@
-import { type Static, type TObject, type TProperties, type TSchema } from "typebox";
+import Type, { type Static, type TObject, type TProperties, type TSchema } from "typebox";
 import type { BaseError } from "@qlever-llc/result";
-import type { AuthMeResponse } from "../auth/protocol.js";
+import type { AuthSessionsMeResponse } from "../auth/protocol.js";
 import { TrellisError } from "../errors/TrellisError.js";
-import type { AuthLogoutInput, AuthLogoutResponse } from "../models/auth/rpc/Logout.js";
+import type { AuthSessionsLogoutInput, AuthSessionsLogoutResponse } from "../models/auth/rpc/Logout.js";
 import type { StateDeleteInput, StateDeleteResponse } from "../models/trellis/rpc/StateDelete.js";
 import type { StateGetInput, StateGetResponse } from "../models/trellis/rpc/StateGet.js";
 import type { StateListInput, StateListResponse } from "../models/trellis/rpc/StateList.js";
 import type { StatePutInput, StatePutResponse } from "../models/trellis/rpc/StatePut.js";
 import { canonicalizeJson, digestJson, isJsonValue, type JsonValue } from "./canonical.js";
-import { type EventDesc, type InferRuntimeRpcError, type InferSchemaType, type OperationDesc, type RPCDesc, type RpcErrorClass, type RuntimeRpcErrorDesc, type Schema, schema, type SchemaLike, type SerializableErrorData, type TrellisAPI, unwrapSchema } from "./runtime.js";
+import { type EventDesc, type FeedDesc, type InferRuntimeRpcError, type InferSchemaType, type OperationDesc, type RPCDesc, type RpcErrorClass, type RuntimeRpcErrorDesc, type Schema, schema, type SchemaLike, type SerializableErrorData, type TrellisAPI, unwrapSchema } from "./runtime.js";
 import { type SubjectParam } from "./schema_pointers.js";
-export { ContractJobQueueSchema, ContractJobsSchema, ContractKvResourceSchema, ContractResourceBindingsSchema, ContractResourcesSchema, ContractSchemaRefSchema, ContractStateSchema, ContractStateStoreSchema, ContractStoreResourceSchema, type EventHeader, EventHeaderSchema, type InstalledServiceContract, InstalledServiceContractSchema, IsoDateSchema, type JobsQueueBinding, JobsQueueBindingSchema, type JobsResourceBinding, JobsResourceBindingSchema, type KvResourceBinding, KvResourceBindingSchema, type Paginated, PaginatedSchema, type StoreResourceBinding, StoreResourceBindingSchema, } from "./protocol.js";
+export { ContractJobQueueSchema, ContractJobsSchema, ContractKvResourceSchema, ContractResourceBindingsSchema, ContractResourcesSchema, ContractSchemaRefSchema, ContractStateSchema, ContractStateStoreSchema, ContractStoreResourceSchema, type EventHeader, EventHeaderSchema, type InstalledServiceContract, InstalledServiceContractSchema, IsoDateSchema, type JobsQueueBinding, JobsQueueBindingSchema, type JobsResourceBinding, JobsResourceBindingSchema, type KvResourceBinding, KvResourceBindingSchema, type PageRequest, PageRequestSchema, type PageResponse, PageResponseSchema, type StoreResourceBinding, StoreResourceBindingSchema, } from "./protocol.js";
 export declare const CONTRACT_FORMAT_V1: "trellis.contract.v1";
 export declare const CATALOG_FORMAT_V1: "trellis.catalog.v1";
+export declare const ContractCapabilityMetadataSchema: Type.TObject<{
+    displayName: Type.TString;
+    description: Type.TString;
+    consequence: Type.TOptional<Type.TString>;
+}>;
+export declare const ContractCapabilitiesSchema: Type.TRecord<"^.*$", Type.TObject<{
+    displayName: Type.TString;
+    description: Type.TString;
+    consequence: Type.TOptional<Type.TString>;
+}>>;
+export declare const ContractExportsSchema: Type.TObject<{
+    schemas: Type.TOptional<Type.TArray<Type.TString>>;
+}>;
+export declare const ContractUsesSchema: Type.TObject<{
+    required: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+        contract: Type.TString;
+        rpc: Type.TOptional<Type.TObject<{
+            call: Type.TOptional<Type.TArray<Type.TString>>;
+        }>>;
+        operations: Type.TOptional<Type.TObject<{
+            call: Type.TOptional<Type.TArray<Type.TString>>;
+        }>>;
+        events: Type.TOptional<Type.TObject<{
+            publish: Type.TOptional<Type.TArray<Type.TString>>;
+            subscribe: Type.TOptional<Type.TArray<Type.TString>>;
+        }>>;
+        feeds: Type.TOptional<Type.TObject<{
+            subscribe: Type.TOptional<Type.TArray<Type.TString>>;
+        }>>;
+    }>>>;
+    optional: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+        contract: Type.TString;
+        rpc: Type.TOptional<Type.TObject<{
+            call: Type.TOptional<Type.TArray<Type.TString>>;
+        }>>;
+        operations: Type.TOptional<Type.TObject<{
+            call: Type.TOptional<Type.TArray<Type.TString>>;
+        }>>;
+        events: Type.TOptional<Type.TObject<{
+            publish: Type.TOptional<Type.TArray<Type.TString>>;
+            subscribe: Type.TOptional<Type.TArray<Type.TString>>;
+        }>>;
+        feeds: Type.TOptional<Type.TObject<{
+            subscribe: Type.TOptional<Type.TArray<Type.TString>>;
+        }>>;
+    }>>>;
+}>;
+export declare const TrellisContractV1Schema: Type.TObject<{
+    format: Type.TLiteral<"trellis.contract.v1">;
+    id: Type.TString;
+    displayName: Type.TString;
+    description: Type.TString;
+    kind: Type.TUnion<[Type.TLiteral<"service">, Type.TLiteral<"app">, Type.TLiteral<"device">, Type.TLiteral<"agent">]>;
+    capabilities: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+        displayName: Type.TString;
+        description: Type.TString;
+        consequence: Type.TOptional<Type.TString>;
+    }>>>;
+    schemas: Type.TOptional<Type.TRecord<"^.*$", Type.TUnion<[Type.TObject<{}>, Type.TBoolean]>>>;
+    exports: Type.TOptional<Type.TObject<{
+        schemas: Type.TOptional<Type.TArray<Type.TString>>;
+    }>>;
+    uses: Type.TOptional<Type.TObject<{
+        required: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+            contract: Type.TString;
+            rpc: Type.TOptional<Type.TObject<{
+                call: Type.TOptional<Type.TArray<Type.TString>>;
+            }>>;
+            operations: Type.TOptional<Type.TObject<{
+                call: Type.TOptional<Type.TArray<Type.TString>>;
+            }>>;
+            events: Type.TOptional<Type.TObject<{
+                publish: Type.TOptional<Type.TArray<Type.TString>>;
+                subscribe: Type.TOptional<Type.TArray<Type.TString>>;
+            }>>;
+            feeds: Type.TOptional<Type.TObject<{
+                subscribe: Type.TOptional<Type.TArray<Type.TString>>;
+            }>>;
+        }>>>;
+        optional: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+            contract: Type.TString;
+            rpc: Type.TOptional<Type.TObject<{
+                call: Type.TOptional<Type.TArray<Type.TString>>;
+            }>>;
+            operations: Type.TOptional<Type.TObject<{
+                call: Type.TOptional<Type.TArray<Type.TString>>;
+            }>>;
+            events: Type.TOptional<Type.TObject<{
+                publish: Type.TOptional<Type.TArray<Type.TString>>;
+                subscribe: Type.TOptional<Type.TArray<Type.TString>>;
+            }>>;
+            feeds: Type.TOptional<Type.TObject<{
+                subscribe: Type.TOptional<Type.TArray<Type.TString>>;
+            }>>;
+        }>>>;
+    }>>;
+    state: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+        kind: Type.TUnion<[Type.TLiteral<"value">, Type.TLiteral<"map">]>;
+        schema: Type.TObject<{
+            schema: Type.TString;
+        }>;
+        stateVersion: Type.TOptional<Type.TString>;
+        acceptedVersions: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+            schema: Type.TString;
+        }>>>;
+    }>>>;
+    rpc: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+        version: Type.TString;
+        subject: Type.TString;
+        input: Type.TObject<{
+            schema: Type.TString;
+        }>;
+        output: Type.TObject<{
+            schema: Type.TString;
+        }>;
+        capabilities: Type.TOptional<Type.TObject<{
+            call: Type.TOptional<Type.TArray<Type.TString>>;
+        }>>;
+        errors: Type.TOptional<Type.TArray<Type.TObject<{
+            type: Type.TString;
+        }>>>;
+        transfer: Type.TOptional<Type.TObject<{
+            direction: Type.TLiteral<"receive">;
+        }>>;
+    }>>>;
+    operations: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+        version: Type.TString;
+        subject: Type.TString;
+        input: Type.TObject<{
+            schema: Type.TString;
+        }>;
+        progress: Type.TOptional<Type.TObject<{
+            schema: Type.TString;
+        }>>;
+        output: Type.TObject<{
+            schema: Type.TString;
+        }>;
+        transfer: Type.TOptional<Type.TObject<{
+            direction: Type.TLiteral<"send">;
+            store: Type.TString;
+            key: Type.TString;
+            contentType: Type.TOptional<Type.TString>;
+            metadata: Type.TOptional<Type.TString>;
+            expiresInMs: Type.TOptional<Type.TInteger>;
+            maxBytes: Type.TOptional<Type.TInteger>;
+        }>>;
+        capabilities: Type.TOptional<Type.TObject<{
+            call: Type.TOptional<Type.TArray<Type.TString>>;
+            read: Type.TOptional<Type.TArray<Type.TString>>;
+            cancel: Type.TOptional<Type.TArray<Type.TString>>;
+            control: Type.TOptional<Type.TArray<Type.TString>>;
+        }>>;
+        signals: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+            input: Type.TObject<{
+                schema: Type.TString;
+            }>;
+        }>>>;
+        cancel: Type.TOptional<Type.TBoolean>;
+    }>>>;
+    events: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+        version: Type.TString;
+        subject: Type.TString;
+        params: Type.TOptional<Type.TArray<Type.TString>>;
+        event: Type.TObject<{
+            schema: Type.TString;
+        }>;
+        capabilities: Type.TOptional<Type.TObject<{
+            publish: Type.TOptional<Type.TArray<Type.TString>>;
+            subscribe: Type.TOptional<Type.TArray<Type.TString>>;
+        }>>;
+    }>>>;
+    feeds: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+        version: Type.TString;
+        subject: Type.TString;
+        input: Type.TObject<{
+            schema: Type.TString;
+        }>;
+        event: Type.TObject<{
+            schema: Type.TString;
+        }>;
+        capabilities: Type.TOptional<Type.TObject<{
+            subscribe: Type.TOptional<Type.TArray<Type.TString>>;
+        }>>;
+    }>>>;
+    errors: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+        type: Type.TString;
+        schema: Type.TOptional<Type.TObject<{
+            schema: Type.TString;
+        }>>;
+    }>>>;
+    jobs: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+        payload: Type.TObject<{
+            schema: Type.TString;
+        }>;
+        result: Type.TOptional<Type.TObject<{
+            schema: Type.TString;
+        }>>;
+        maxDeliver: Type.TOptional<Type.TInteger>;
+        backoffMs: Type.TOptional<Type.TArray<Type.TInteger>>;
+        ackWaitMs: Type.TOptional<Type.TInteger>;
+        defaultDeadlineMs: Type.TOptional<Type.TInteger>;
+        progress: Type.TOptional<Type.TBoolean>;
+        logs: Type.TOptional<Type.TBoolean>;
+        dlq: Type.TOptional<Type.TBoolean>;
+        concurrency: Type.TOptional<Type.TInteger>;
+    }>>>;
+    resources: Type.TOptional<Type.TObject<{
+        kv: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+            purpose: Type.TString;
+            schema: Type.TObject<{
+                schema: Type.TString;
+            }>;
+            required: Type.TOptional<Type.TBoolean>;
+            history: Type.TOptional<Type.TInteger>;
+            ttlMs: Type.TOptional<Type.TInteger>;
+            maxValueBytes: Type.TOptional<Type.TInteger>;
+        }>>>;
+        store: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
+            purpose: Type.TString;
+            required: Type.TOptional<Type.TBoolean>;
+            ttlMs: Type.TOptional<Type.TInteger>;
+            maxObjectBytes: Type.TOptional<Type.TInteger>;
+            maxTotalBytes: Type.TOptional<Type.TInteger>;
+        }>>>;
+    }>>;
+}>;
+export declare const TrellisCatalogV1Schema: Type.TObject<{
+    format: Type.TLiteral<"trellis.catalog.v1">;
+    contracts: Type.TArray<Type.TObject<{
+        id: Type.TString;
+        digest: Type.TString;
+        displayName: Type.TString;
+        description: Type.TString;
+    }>>;
+}>;
 declare const CONTRACT_MODULE_METADATA: unique symbol;
 export declare const CONTRACT_JOBS_METADATA: unique symbol;
 export declare const CONTRACT_KV_METADATA: unique symbol;
@@ -30,6 +265,16 @@ export type ContractManifestMetadata = {
 };
 export type ContractKind = "service" | "app" | "device" | "agent";
 export type Capability = string;
+export type PlatformCapability = "admin" | "service";
+export type GlobalCapability = `${string}::${string}`;
+export type ContractCapabilityMetadata = {
+    displayName: string;
+    description: string;
+    consequence?: string;
+};
+export type ContractCapabilities = Record<string, ContractCapabilityMetadata>;
+type DeclaredCapabilityName<TCapabilities> = [TCapabilities] extends [undefined] ? never : Extract<keyof NonNullable<TCapabilities>, string>;
+type CapabilityRef<TCapabilities> = DeclaredCapabilityName<TCapabilities> | GlobalCapability | PlatformCapability;
 export type JsonSchema = JsonValue | boolean;
 export type ContractSchemaRef<TSchemaName extends string = string> = {
     schema: TSchemaName;
@@ -39,6 +284,7 @@ type ErrorNameOf<TErrors> = Extract<keyof NonNullable<TErrors>, string> | Builti
 export type ContractRefBuilder<TSchemas extends Readonly<Record<string, TSchema>> | undefined = undefined, TErrors extends Readonly<Record<string, ErrorClass>> | undefined = undefined> = {
     schema<const TName extends SchemaNameOf<TSchemas>>(schemaName: TName): ContractSchemaRef<TName>;
     error<const TName extends ErrorNameOf<TErrors>>(errorName: TName): TName;
+    capability<const TName extends GlobalCapability | PlatformCapability>(capabilityName: TName): TName;
 };
 export type ContractSchemas = Record<string, JsonSchema>;
 export type ContractExports<TSchemaName extends string = string> = {
@@ -96,7 +342,11 @@ export type ContractOperation = {
         call?: Capability[];
         read?: Capability[];
         cancel?: Capability[];
+        control?: Capability[];
     };
+    signals?: Record<string, {
+        input: ContractSchemaRef;
+    }>;
     cancel?: boolean;
 };
 export type ContractEvent = {
@@ -109,6 +359,15 @@ export type ContractEvent = {
         subscribe?: Capability[];
     };
 };
+export type ContractFeed = {
+    version: `v${number}`;
+    subject: string;
+    input: ContractSchemaRef;
+    event: ContractSchemaRef;
+    capabilities?: {
+        subscribe?: Capability[];
+    };
+};
 export type ContractJobQueueResource = {
     payload: ContractSchemaRef;
     result?: ContractSchemaRef;
@@ -154,14 +413,22 @@ export type ContractUse = {
     rpc?: ContractUsesRpc;
     operations?: ContractUsesRpc;
     events?: ContractUsesPubSub;
+    feeds?: {
+        subscribe?: string[];
+    };
+};
+export type ContractUsesGrouped = {
+    required?: Record<string, ContractUse>;
+    optional?: Record<string, ContractUse>;
 };
-export type ContractUses = Record<string, ContractUse>;
+export type ContractUses = ContractUsesGrouped;
 export type TrellisContractV1 = {
     format: typeof CONTRACT_FORMAT_V1;
     id: string;
     displayName: string;
     description: string;
     kind: ContractKind;
+    capabilities?: ContractCapabilities;
     schemas?: ContractSchemas;
     exports?: ContractExports;
     state?: ContractState;
@@ -169,6 +436,7 @@ export type TrellisContractV1 = {
     rpc?: Record<string, ContractRpcMethod>;
     operations?: Record<string, ContractOperation>;
     events?: Record<string, ContractEvent>;
+    feeds?: Record<string, ContractFeed>;
     errors?: Record<string, ContractErrorDecl>;
     jobs?: ContractJobs;
     resources?: ContractResources;
@@ -231,12 +499,12 @@ export type ContractSourceStateStore<TSchemaName extends string = string> = {
     acceptedVersions?: Record<string, ContractSchemaRef<TSchemaName>>;
 };
 export type ContractSourceState<TSchemaName extends string = string> = Record<string, ContractSourceStateStore<TSchemaName>>;
-export type ContractSourceRpcMethod<TSchemaName extends string = string, TErrorName extends string = string> = {
+export type ContractSourceRpcMethod<TSchemaName extends string = string, TErrorName extends string = string, TCapability extends string = Capability> = {
     version: `v${number}`;
     input: ContractSchemaRef<TSchemaName>;
     output: ContractSchemaRef<TSchemaName>;
     capabilities?: {
-        call?: readonly Capability[];
+        call?: readonly TCapability[];
     };
     transfer?: {
         direction: "receive";
@@ -245,7 +513,7 @@ export type ContractSourceRpcMethod<TSchemaName extends string = string, TErrorN
     authRequired?: boolean;
     subject?: string;
 };
-export type ContractSourceOperation<TSchemaName extends string = string> = {
+export type ContractSourceOperation<TSchemaName extends string = string, TCapability extends string = Capability> = {
     version: `v${number}`;
     input: ContractSchemaRef<TSchemaName>;
     progress?: ContractSchemaRef<TSchemaName>;
@@ -260,20 +528,33 @@ export type ContractSourceOperation<TSchemaName extends string = string> = {
         maxBytes?: number;
     };
     capabilities?: {
-        call?: readonly Capability[];
-        read?: readonly Capability[];
-        cancel?: readonly Capability[];
+        call?: readonly TCapability[];
+        read?: readonly TCapability[];
+        cancel?: readonly TCapability[];
+        control?: readonly TCapability[];
     };
+    signals?: Record<string, {
+        input: ContractSchemaRef<TSchemaName>;
+    }>;
     cancel?: boolean;
     subject?: string;
 };
-export type ContractSourceEvent<TSchemaName extends string = string> = {
+export type ContractSourceEvent<TSchemaName extends string = string, TCapability extends string = Capability> = {
     version: `v${number}`;
     event: ContractSchemaRef<TSchemaName>;
     params?: readonly SubjectParam[];
     capabilities?: {
-        publish?: readonly Capability[];
-        subscribe?: readonly Capability[];
+        publish?: readonly TCapability[];
+        subscribe?: readonly TCapability[];
+    };
+    subject?: string;
+};
+export type ContractSourceFeed<TSchemaName extends string = string, TCapability extends string = Capability> = {
+    version: `v${number}`;
+    input: ContractSchemaRef<TSchemaName>;
+    event: ContractSchemaRef<TSchemaName>;
+    capabilities?: {
+        subscribe?: readonly TCapability[];
     };
     subject?: string;
 };
@@ -321,19 +602,29 @@ export type ContractSourceUse = {
         publish?: readonly string[];
         subscribe?: readonly string[];
     };
+    feeds?: {
+        subscribe?: readonly string[];
+    };
 };
+export type ContractSourceUsesGrouped = {
+    required?: Record<string, ContractSourceUse>;
+    optional?: Record<string, ContractSourceUse>;
+};
+export type ContractSourceUses = ContractSourceUsesGrouped;
 export type TrellisContractSource = {
     id: string;
     displayName: string;
     description: string;
     kind: ContractKind;
+    capabilities?: ContractCapabilities;
     schemas?: ContractSourceSchemas;
     exports?: ContractSourceExports;
     state?: ContractSourceState;
-    uses?: Record<string, ContractSourceUse>;
+    uses?: ContractSourceUses;
     rpc?: Record<string, ContractSourceRpcMethod>;
     operations?: Record<string, ContractSourceOperation>;
     events?: Record<string, ContractSourceEvent>;
+    feeds?: Record<string, ContractSourceFeed>;
     errors?: Record<string, ContractSourceErrorDecl>;
     jobs?: ContractSourceJobs;
     resources?: ContractSourceResources;
@@ -342,27 +633,31 @@ export type TrellisApiLike = {
     rpc: Record<string, RPCDesc>;
     operations: Record<string, OperationDesc>;
     events: Record<string, EventDesc>;
+    feeds?: Record<string, FeedDesc>;
     subjects: Record<string, unknown>;
 };
 type ApiShape = {
     rpc: Record<string, unknown>;
     operations: Record<string, unknown>;
     events: Record<string, unknown>;
+    feeds?: Record<string, unknown>;
     subjects: Record<string, unknown>;
 };
 export type EmptyApi = {
     rpc: {};
     operations: {};
     events: {};
+    feeds?: {};
     subjects: {};
 };
 type BaselineAuthApi = {
     rpc: {
-        "Auth.Me": RPCDesc<Schema<Record<string, never>>, Schema<AuthMeResponse>>;
-        "Auth.Logout": RPCDesc<Schema<AuthLogoutInput>, Schema<AuthLogoutResponse>>;
+        "Auth.Sessions.Me": RPCDesc<Schema<Record<string, never>>, Schema<AuthSessionsMeResponse>>;
+        "Auth.Sessions.Logout": RPCDesc<Schema<AuthSessionsLogoutInput>, Schema<AuthSessionsLogoutResponse>>;
     };
     operations: {};
     events: {};
+    feeds: {};
     subjects: {};
 };
 type BaselineStateApi = {
@@ -374,6 +669,16 @@ type BaselineStateApi = {
     };
     operations: {};
     events: {};
+    feeds: {};
+    subjects: {};
+};
+type BaselineHealthApi = {
+    rpc: {};
+    operations: {};
+    events: {
+        "Health.Heartbeat": EventDesc<Schema<Record<string, unknown>>>;
+    };
+    feeds: {};
     subjects: {};
 };
 export type ContractApiViews<TOwnedApi extends ApiShape, TUsedApi extends ApiShape, TTrellisApi extends ApiShape> = {
@@ -392,6 +697,9 @@ export type UseSpec<TApi extends ApiShape> = {
         publish?: readonly StringKeyOf<TApi["events"]>[];
         subscribe?: readonly StringKeyOf<TApi["events"]>[];
     };
+    feeds?: {
+        subscribe?: readonly StringKeyOf<NonNullable<TApi["feeds"]>>[];
+    };
 };
 type UseRpcCall<TSpec> = NonNullable<TSpec extends {
     rpc?: infer TRpc;
@@ -413,6 +721,11 @@ type UseEventsSubscribe<TSpec> = NonNullable<TSpec extends {
 } ? TEvents : never> extends {
     subscribe?: infer TSubscribe extends readonly string[] | undefined;
 } ? TSubscribe : never;
+type UseFeedsSubscribe<TSpec> = NonNullable<TSpec extends {
+    feeds?: infer TFeeds;
+} ? TFeeds : never> extends {
+    subscribe?: infer TSubscribe extends readonly string[] | undefined;
+} ? TSubscribe : never;
 export type ContractDependencyUse<TContractId extends string, TApi extends ApiShape, TSpec extends UseSpec<TApi> = UseSpec<TApi>> = {
     contract: TContractId;
     readonly [CONTRACT_MODULE_METADATA]?: ContractModule<TContractId, TApi, ApiShape, ApiShape>;
@@ -426,8 +739,17 @@ export type ContractDependencyUse<TContractId extends string, TApi extends ApiSh
         publish?: UseEventsPublish<TSpec>;
         subscribe?: UseEventsSubscribe<TSpec>;
     };
+    feeds?: {
+        subscribe?: UseFeedsSubscribe<TSpec>;
+    };
 };
 type AuthorContractDependencyUse = ContractDependencyUse<string, ApiShape, UseSpec<ApiShape>>;
+type AuthorContractUsesFlat = Readonly<Record<string, AuthorContractDependencyUse>>;
+type AuthorContractUsesGrouped = {
+    required?: AuthorContractUsesFlat;
+    optional?: AuthorContractUsesFlat;
+};
+type AuthorContractUses = AuthorContractUsesGrouped;
 export type ContractUseFn<TContractId extends string, TApi extends ApiShape> = <const TSpec extends UseSpec<TApi>>(spec: TSpec) => ContractDependencyUse<TContractId, TApi, TSpec>;
 type MergeRecordUnion<U> = [U] extends [never] ? {} : Simplify<UnionToIntersection<U>>;
 type SchemaNameOf<TSchemas> = Extract<keyof NonNullable<TSchemas>, string>;
@@ -517,27 +839,32 @@ type ProjectedRpcMethod<TMethod extends ContractSourceRpcMethod, TSchemas, _TErr
 } ? {
     transfer: TTransfer;
 } : {});
-type ProjectedRpc<T extends Readonly<Record<string, ContractSourceRpcMethod>> | undefined, TSchemas, TErrors> = T extends Readonly<Record<string, ContractSourceRpcMethod>> ? {
+type ProjectedRpc<T, TSchemas, TErrors> = T extends Readonly<Record<string, ContractSourceRpcMethod>> ? {
     [K in keyof T]: ProjectedRpcMethod<T[K], TSchemas, TErrors>;
 } : {};
-type ProjectedOperations<T extends Readonly<Record<string, ContractSourceOperation>> | undefined, TSchemas> = T extends Readonly<Record<string, ContractSourceOperation>> ? {
+type ProjectedOperations<T, TSchemas> = T extends Readonly<Record<string, ContractSourceOperation>> ? {
     [K in keyof T]: OperationDesc<ResolveSchemaFromMap<TSchemas, T[K]["input"]>, ResolveSchemaFromMap<TSchemas, T[K]["progress"]>, ResolveSchemaFromMap<TSchemas, T[K]["output"]>> & (T[K]["transfer"] extends undefined ? {} : {
         transfer: T[K]["transfer"];
     });
 } : {};
-type ProjectedEvents<T extends Readonly<Record<string, ContractSourceEvent>> | undefined, TSchemas> = T extends Readonly<Record<string, ContractSourceEvent>> ? {
+type ProjectedEvents<T, TSchemas> = T extends Readonly<Record<string, ContractSourceEvent>> ? {
     [K in keyof T]: EventDesc<ResolveSchemaFromMap<TSchemas, T[K]["event"]>>;
 } : {};
+type ProjectedFeeds<T, TSchemas> = T extends Readonly<Record<string, ContractSourceFeed>> ? {
+    [K in keyof T]: FeedDesc<ResolveSchemaFromMap<TSchemas, T[K]["input"]>, ResolveSchemaFromMap<TSchemas, T[K]["event"]>>;
+} : {};
 export type OwnedApiFromSource<T extends {
     schemas?: Readonly<Record<string, TSchema>>;
-    errors?: Readonly<Record<string, ErrorClass>>;
-    rpc?: Readonly<Record<string, ContractSourceRpcMethod>>;
-    operations?: Readonly<Record<string, ContractSourceOperation>>;
-    events?: Readonly<Record<string, ContractSourceEvent>>;
+    errors?: unknown;
+    rpc?: unknown;
+    operations?: unknown;
+    events?: unknown;
+    feeds?: unknown;
 }> = {
     rpc: ProjectedRpc<T["rpc"], T["schemas"], T["errors"]>;
     operations: ProjectedOperations<T["operations"], T["schemas"]>;
     events: ProjectedEvents<T["events"], T["schemas"]>;
+    feeds: ProjectedFeeds<T["feeds"], T["schemas"]>;
     subjects: {};
 };
 type RpcKeysFromSpec<TSpec> = TSpec extends {
@@ -559,23 +886,38 @@ type OperationKeysFromSpec<TSpec> = TSpec extends {
         call?: infer TCall;
     };
 } ? KeysFromList<TCall> : never;
+type FeedKeysFromSpec<TSpec> = TSpec extends {
+    feeds?: {
+        subscribe?: infer TSubscribe;
+    };
+} ? KeysFromList<TSubscribe> : never;
 type ApiFromDependencyUse<TUse> = TUse extends ContractDependencyUse<string, infer TApi, infer TSpec> ? {
     rpc: Pick<TApi["rpc"], RpcKeysFromSpec<TSpec>>;
     operations: Pick<TApi["operations"], OperationKeysFromSpec<TSpec>>;
     events: Pick<TApi["events"], EventKeysFromSpec<TSpec>>;
+    feeds: Pick<NonNullable<TApi["feeds"]>, FeedKeysFromSpec<TSpec>>;
     subjects: {};
 } : EmptyApi;
+type DependencyUsesFromUses<TUses> = TUses extends {
+    required?: AuthorContractUsesFlat;
+    optional?: AuthorContractUsesFlat;
+} ? NonNullable<TUses["required"]>[keyof NonNullable<TUses["required"]>] | NonNullable<TUses["optional"]>[keyof NonNullable<TUses["optional"]>] : never;
 export type UsedApiFromUses<TUses> = [TUses] extends [undefined] ? EmptyApi : TUses extends Record<string, unknown> ? {
-    rpc: MergeRecordUnion<ApiFromDependencyUse<TUses[keyof TUses]>["rpc"]>;
-    operations: MergeRecordUnion<ApiFromDependencyUse<TUses[keyof TUses]>["operations"]>;
-    events: MergeRecordUnion<ApiFromDependencyUse<TUses[keyof TUses]>["events"]>;
-    subjects: MergeRecordUnion<ApiFromDependencyUse<TUses[keyof TUses]>["subjects"]>;
+    rpc: MergeRecordUnion<ApiFromDependencyUse<DependencyUsesFromUses<TUses>>["rpc"]>;
+    operations: MergeRecordUnion<ApiFromDependencyUse<DependencyUsesFromUses<TUses>>["operations"]>;
+    events: MergeRecordUnion<ApiFromDependencyUse<DependencyUsesFromUses<TUses>>["events"]>;
+    feeds: MergeRecordUnion<ApiFromDependencyUse<DependencyUsesFromUses<TUses>>["feeds"]>;
+    subjects: MergeRecordUnion<ApiFromDependencyUse<DependencyUsesFromUses<TUses>>["subjects"]>;
 } : EmptyApi;
 type ImplicitAuthApiForKind<TKind> = TKind extends "app" | "agent" | "device" ? BaselineAuthApi : EmptyApi;
 type ImplicitStateApiForSource<T> = [StateFromSource<T>] extends [undefined] ? EmptyApi : BaselineStateApi;
+type ImplicitHealthApiForSource<T> = T extends {
+    kind: infer TKind;
+    id: infer TId;
+} ? TId extends "trellis.health@v1" ? EmptyApi : TKind extends "service" | "device" ? BaselineHealthApi : EmptyApi : EmptyApi;
 type ImplicitTrellisApiFromSource<T> = T extends {
     kind: infer TKind;
-} ? MergeApis<ImplicitAuthApiForKind<TKind>, ImplicitStateApiForSource<T>> : EmptyApi;
+} ? MergeApis<MergeApis<ImplicitAuthApiForKind<TKind>, ImplicitStateApiForSource<T>>, ImplicitHealthApiForSource<T>> : EmptyApi;
 export type UsedApiFromSource<T extends {
     uses?: unknown;
 }> = MergeApis<UsedApiFromUses<T["uses"]>, ImplicitTrellisApiFromSource<T>>;
@@ -583,6 +925,7 @@ export type MergeApis<TOwnedApi extends ApiShape, TUsedApi extends ApiShape> = {
     rpc: Simplify<TUsedApi["rpc"] & TOwnedApi["rpc"]>;
     operations: Simplify<TUsedApi["operations"] & TOwnedApi["operations"]>;
     events: Simplify<TUsedApi["events"] & TOwnedApi["events"]>;
+    feeds: Simplify<TUsedApi["feeds"] & TOwnedApi["feeds"]>;
     subjects: Simplify<TUsedApi["subjects"] & TOwnedApi["subjects"]>;
 };
 export type ContractModule<TContractId extends string, TOwnedApi extends ApiShape, TUsedApi extends ApiShape, TTrellisApi extends ApiShape, TJobs extends ContractJobsMetadata = {}, TState extends ContractStateMetadata = {}, TKv extends ContractKvMetadata = ContractKvMetadata> = {
@@ -599,11 +942,12 @@ export type SdkContractModule<TContractId extends string, TOwnedApi extends ApiS
     use: ContractUseFn<TContractId, TOwnedApi>;
 };
 export type DefinedContract<TOwnedApi extends ApiShape, TUsedApi extends ApiShape, TTrellisApi extends ApiShape, TContractId extends string = string, TJobs extends ContractJobsMetadata = {}, TState extends ContractStateMetadata = {}, TKv extends ContractKvMetadata = ContractKvMetadata> = ContractModule<TContractId, TOwnedApi, TUsedApi, TTrellisApi, TJobs, TState, TKv>;
-export type DefineContractInput<TSchemas extends Readonly<Record<string, TSchema>> | undefined = undefined, TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined = undefined, TErrors extends Readonly<Record<string, ErrorClass>> | undefined = undefined, TRpc extends Readonly<Record<string, ContractSourceRpcMethod<SchemaNameOf<TSchemas>, ErrorNameOf<TErrors>>>> | undefined = undefined, TOperations extends Readonly<Record<string, ContractSourceOperation<SchemaNameOf<TSchemas>>>> | undefined = undefined, TEvents extends Readonly<Record<string, ContractSourceEvent<SchemaNameOf<TSchemas>>>> | undefined = undefined> = {
+export type DefineContractInput<TCapabilities extends ContractCapabilities | undefined = ContractCapabilities | undefined, TSchemas extends Readonly<Record<string, TSchema>> | undefined = undefined, TUses extends AuthorContractUses | undefined = undefined, TErrors extends Readonly<Record<string, ErrorClass>> | undefined = undefined, TRpc extends Readonly<Record<string, ContractSourceRpcMethod<SchemaNameOf<TSchemas>, ErrorNameOf<TErrors>, CapabilityRef<TCapabilities>>>> | undefined = undefined, TOperations extends Readonly<Record<string, ContractSourceOperation<SchemaNameOf<TSchemas>, CapabilityRef<TCapabilities>>>> | undefined = undefined, TEvents extends Readonly<Record<string, ContractSourceEvent<SchemaNameOf<TSchemas>, CapabilityRef<TCapabilities>>>> | undefined = undefined> = {
     id: string;
     displayName: string;
     description: string;
     kind: ContractKind;
+    capabilities?: ContractCapabilities;
     schemas?: TSchemas;
     exports?: ContractSourceExports<SchemaNameOf<TSchemas>>;
     state?: ContractSourceState<SchemaNameOf<TSchemas>>;
@@ -612,6 +956,7 @@ export type DefineContractInput<TSchemas extends Readonly<Record<string, TSchema
     rpc?: TRpc;
     operations?: TOperations;
     events?: TEvents;
+    feeds?: Readonly<Record<string, ContractSourceFeed<SchemaNameOf<TSchemas>, CapabilityRef<TCapabilities>>>>;
     jobs?: ContractSourceJobs<SchemaNameOf<TSchemas>>;
     resources?: ContractSourceResources<SchemaNameOf<TSchemas>>;
 };
@@ -629,15 +974,16 @@ type RegistrySchemas<TRegistry extends AnyDefineContractRegistry> = TRegistry ex
 type RegistryErrors<TRegistry extends AnyDefineContractRegistry> = TRegistry extends {
     errors?: infer TErrors;
 } ? TErrors extends Readonly<Record<string, unknown>> | undefined ? ExtractErrorClasses<TErrors> : undefined : undefined;
-type DefineContractBodyInput<TSchemas extends Readonly<Record<string, TSchema>> | undefined = undefined, TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined = undefined, TErrors extends Readonly<Record<string, ErrorClass>> | undefined = undefined, TRpc extends Readonly<Record<string, ContractSourceRpcMethod<SchemaNameOf<TSchemas>, ErrorNameOf<TErrors>>>> | undefined = undefined, TOperations extends Readonly<Record<string, ContractSourceOperation<SchemaNameOf<TSchemas>>>> | undefined = undefined, TEvents extends Readonly<Record<string, ContractSourceEvent<SchemaNameOf<TSchemas>>>> | undefined = undefined> = Omit<DefineContractInput<TSchemas, TUses, TErrors, TRpc, TOperations, TEvents>, "schemas" | "errors"> & {
+type DefineContractBodyInput<TCapabilities extends ContractCapabilities | undefined = ContractCapabilities | undefined, TSchemas extends Readonly<Record<string, TSchema>> | undefined = undefined, TUses extends AuthorContractUses | undefined = undefined, TErrors extends Readonly<Record<string, ErrorClass>> | undefined = undefined, TRpc extends Readonly<Record<string, ContractSourceRpcMethod<SchemaNameOf<TSchemas>, ErrorNameOf<TErrors>, CapabilityRef<TCapabilities>>>> | undefined = undefined, TOperations extends Readonly<Record<string, ContractSourceOperation<SchemaNameOf<TSchemas>, CapabilityRef<TCapabilities>>>> | undefined = undefined, TEvents extends Readonly<Record<string, ContractSourceEvent<SchemaNameOf<TSchemas>, CapabilityRef<TCapabilities>>>> | undefined = undefined> = Omit<DefineContractInput<TCapabilities, TSchemas, TUses, TErrors, TRpc, TOperations, TEvents>, "schemas" | "errors"> & {
     schemas?: never;
     errors?: never;
 };
-type ServiceContractBodyInput<TSchemas extends Readonly<Record<string, TSchema>> | undefined = undefined, TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined = undefined, TErrors extends Readonly<Record<string, ErrorClass>> | undefined = undefined, TRpc extends Readonly<Record<string, ContractSourceRpcMethod<SchemaNameOf<TSchemas>, ErrorNameOf<TErrors>>>> | undefined = undefined, TOperations extends Readonly<Record<string, ContractSourceOperation<SchemaNameOf<TSchemas>>>> | undefined = undefined, TEvents extends Readonly<Record<string, ContractSourceEvent<SchemaNameOf<TSchemas>>>> | undefined = undefined> = Omit<DefineContractBodyInput<TSchemas, TUses, TErrors, TRpc, TOperations, TEvents>, "kind"> & {
+type ServiceContractBodyInput<TCapabilities extends ContractCapabilities | undefined = ContractCapabilities | undefined, TSchemas extends Readonly<Record<string, TSchema>> | undefined = undefined, TUses extends AuthorContractUses | undefined = undefined, TErrors extends Readonly<Record<string, ErrorClass>> | undefined = undefined, TRpc extends Readonly<Record<string, ContractSourceRpcMethod<SchemaNameOf<TSchemas>, ErrorNameOf<TErrors>, CapabilityRef<TCapabilities>>>> | undefined = undefined, TOperations extends Readonly<Record<string, ContractSourceOperation<SchemaNameOf<TSchemas>, CapabilityRef<TCapabilities>>>> | undefined = undefined, TEvents extends Readonly<Record<string, ContractSourceEvent<SchemaNameOf<TSchemas>, CapabilityRef<TCapabilities>>>> | undefined = undefined> = Omit<DefineContractBodyInput<TCapabilities, TSchemas, TUses, TErrors, TRpc, TOperations, TEvents>, "kind"> & {
     kind?: never;
     subjects?: never;
 };
-type ClientContractBodyInput<TSchemas extends Readonly<Record<string, TSchema>> | undefined = undefined, TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined = undefined> = ContractIdentityFields & {
+type ClientContractBodyInput<TSchemas extends Readonly<Record<string, TSchema>> | undefined = undefined, TUses extends AuthorContractUses | undefined = undefined> = ContractIdentityFields & {
+    capabilities?: ContractCapabilities;
     exports?: ContractSourceExports<SchemaNameOf<TSchemas>>;
     state?: ContractSourceState<SchemaNameOf<TSchemas>>;
     uses?: TUses;
@@ -652,12 +998,41 @@ type ClientContractBodyInput<TSchemas extends Readonly<Record<string, TSchema>>
 };
 type BuiltContractSource<TRegistry extends AnyDefineContractRegistry, TBody extends {
     id: string;
-}> = Simplify<Omit<TBody, "schemas" | "errors"> & Pick<TRegistry, Extract<keyof TRegistry, "schemas" | "errors">>>;
+}> = Simplify<Omit<TBody, "schemas" | "errors"> & (TRegistry extends {
+    schemas?: infer TSchemas;
+} ? {
+    schemas?: TSchemas;
+} : {}) & (TRegistry extends {
+    errors?: infer TErrors;
+} ? {
+    errors?: TErrors;
+} : {})>;
 type WithKind<TBody extends {
     id: string;
 }, TKind extends ContractKind> = Simplify<Omit<TBody, "kind"> & {
     kind: TKind;
 }>;
+/** Return the global capability namespace for a contract id. */
+export declare function contractCapabilityNamespace(contractId: string): string;
+/** Return the globally qualified name for a contract-local capability. */
+export declare function globalCapabilityName(contractId: string, localCapability: string): string;
+/**
+ * Return the canonical manifest shape used by Trellis runtimes before
+ * validation, persistence, and digesting.
+ *
+ * This is not the digest projection: human-facing fields such as
+ * `displayName` and `description` are preserved here even though they are not
+ * part of contract identity. Unknown extension fields are intentionally omitted
+ * until the runtime explicitly supports them.
+ */
+export declare function normalizeContractManifest(contract: TrellisContractV1): TrellisContractV1;
+/**
+ * Parse untrusted contract JSON into the current Trellis v1 manifest shape.
+ *
+ * Unknown extension fields are accepted for forward compatibility but are not
+ * returned. Callers must use the returned value for persistence and digesting.
+ */
+export declare function parseContractManifest(value: unknown): TrellisContractV1;
 /**
  * Build the normalized runtime/interface projection used for contract identity.
  */
@@ -671,21 +1046,25 @@ export declare function digestContractManifest(contract: TrellisContractV1): str
  * and reconstruction logic needed by `defineServiceContract(...)`.
  */
 export declare function defineError<const TType extends string, const TFields extends TProperties>(options: DefineErrorOptions<TType, TFields>): DefinedErrorClass<TType, TFields>;
-export declare function defineServiceContract<const TErrors extends Readonly<Record<string, unknown>> | undefined, const TRegistry extends DefineContractRegistry<Readonly<Record<string, TSchema>> | undefined, TErrors>, const TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined, const TRpc extends Readonly<Record<string, ContractSourceRpcMethod<SchemaNameOf<RegistrySchemas<TRegistry>>, ErrorNameOf<RegistryErrors<TRegistry>>>>> | undefined, const TOperations extends Readonly<Record<string, ContractSourceOperation<SchemaNameOf<RegistrySchemas<TRegistry>>>>> | undefined, const TEvents extends Readonly<Record<string, ContractSourceEvent<SchemaNameOf<RegistrySchemas<TRegistry>>>>> | undefined, const TBody extends ServiceContractBodyInput<RegistrySchemas<TRegistry>, TUses, RegistryErrors<TRegistry>, TRpc, TOperations, TEvents>>(registry: TRegistry & {
+export declare function defineServiceContract<const TErrors extends Readonly<Record<string, unknown>> | undefined, const TRegistry extends DefineContractRegistry<Readonly<Record<string, TSchema>> | undefined, TErrors>, const TCapabilities extends ContractCapabilities | undefined, const TUses extends AuthorContractUses | undefined, const TRpc extends Readonly<Record<string, ContractSourceRpcMethod<SchemaNameOf<RegistrySchemas<TRegistry>>, ErrorNameOf<RegistryErrors<TRegistry>>, CapabilityRef<TCapabilities>>>> | undefined, const TOperations extends Readonly<Record<string, ContractSourceOperation<SchemaNameOf<RegistrySchemas<TRegistry>>, CapabilityRef<TCapabilities>>>> | undefined, const TEvents extends Readonly<Record<string, ContractSourceEvent<SchemaNameOf<RegistrySchemas<TRegistry>>, CapabilityRef<TCapabilities>>>> | undefined, const TBody extends ServiceContractBodyInput<TCapabilities, RegistrySchemas<TRegistry>, TUses, RegistryErrors<TRegistry>, TRpc, TOperations, TEvents>>(registry: TRegistry & {
+    capabilities?: never;
     exports?: never;
 }, build: (ref: ContractRefBuilder<RegistrySchemas<TRegistry>, RegistryErrors<TRegistry>>) => TBody): DefinedContract<OwnedApiFromSource<BuiltContractSource<TRegistry, WithKind<TBody, "service">>>, UsedApiFromSource<BuiltContractSource<TRegistry, WithKind<TBody, "service">>>, MergeApis<OwnedApiFromSource<BuiltContractSource<TRegistry, WithKind<TBody, "service">>>, UsedApiFromSource<BuiltContractSource<TRegistry, WithKind<TBody, "service">>>>, TBody["id"], ProjectedJobs<JobsFromSource<BuiltContractSource<TRegistry, WithKind<TBody, "service">>>, SchemasFromSource<BuiltContractSource<TRegistry, WithKind<TBody, "service">>>>, ProjectedState<StateFromSource<BuiltContractSource<TRegistry, WithKind<TBody, "service">>>, SchemasFromSource<BuiltContractSource<TRegistry, WithKind<TBody, "service">>>>, ProjectedKvResources<ResourcesFromSource<BuiltContractSource<TRegistry, WithKind<TBody, "service">>>, SchemasFromSource<BuiltContractSource<TRegistry, WithKind<TBody, "service">>>>>;
-export declare function defineAppContract<const TSchemas extends Readonly<Record<string, TSchema>> | undefined, const TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined, const TBody extends ClientContractBodyInput<TSchemas, TUses>>(registry: ClientContractRegistry<TSchemas> & {
+export declare function defineAppContract<const TSchemas extends Readonly<Record<string, TSchema>> | undefined, const TUses extends AuthorContractUses | undefined, const TBody extends ClientContractBodyInput<TSchemas, TUses>>(registry: ClientContractRegistry<TSchemas> & {
+    capabilities?: never;
     exports?: never;
 }, build: (ref: ContractRefBuilder<TSchemas>) => TBody): DefinedContract<OwnedApiFromSource<BuiltContractSource<ClientContractRegistry<TSchemas>, WithKind<TBody, "app">>>, UsedApiFromSource<BuiltContractSource<ClientContractRegistry<TSchemas>, WithKind<TBody, "app">>>, MergeApis<OwnedApiFromSource<BuiltContractSource<ClientContractRegistry<TSchemas>, WithKind<TBody, "app">>>, UsedApiFromSource<BuiltContractSource<ClientContractRegistry<TSchemas>, WithKind<TBody, "app">>>>, TBody["id"], {}, ProjectedState<StateFromSource<BuiltContractSource<ClientContractRegistry<TSchemas>, WithKind<TBody, "app">>>, SchemasFromSource<BuiltContractSource<ClientContractRegistry<TSchemas>, WithKind<TBody, "app">>>>>;
-export declare function defineAppContract<const TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined, const TBody extends ClientContractBodyInput<undefined, TUses>>(build: () => TBody): DefinedContract<OwnedApiFromSource<WithKind<TBody, "app">>, UsedApiFromSource<WithKind<TBody, "app">>, MergeApis<OwnedApiFromSource<WithKind<TBody, "app">>, UsedApiFromSource<WithKind<TBody, "app">>>, TBody["id"], {}, ProjectedState<StateFromSource<WithKind<TBody, "app">>, SchemasFromSource<WithKind<TBody, "app">>>>;
-export declare function defineAgentContract<const TSchemas extends Readonly<Record<string, TSchema>> | undefined, const TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined, const TBody extends ClientContractBodyInput<TSchemas, TUses>>(registry: ClientContractRegistry<TSchemas> & {
+export declare function defineAppContract<const TUses extends AuthorContractUses | undefined, const TBody extends ClientContractBodyInput<undefined, TUses>>(build: () => TBody): DefinedContract<OwnedApiFromSource<WithKind<TBody, "app">>, UsedApiFromSource<WithKind<TBody, "app">>, MergeApis<OwnedApiFromSource<WithKind<TBody, "app">>, UsedApiFromSource<WithKind<TBody, "app">>>, TBody["id"], {}, ProjectedState<StateFromSource<WithKind<TBody, "app">>, SchemasFromSource<WithKind<TBody, "app">>>>;
+export declare function defineAgentContract<const TSchemas extends Readonly<Record<string, TSchema>> | undefined, const TUses extends AuthorContractUses | undefined, const TBody extends ClientContractBodyInput<TSchemas, TUses>>(registry: ClientContractRegistry<TSchemas> & {
+    capabilities?: never;
     exports?: never;
 }, build: (ref: ContractRefBuilder<TSchemas>) => TBody): DefinedContract<OwnedApiFromSource<BuiltContractSource<ClientContractRegistry<TSchemas>, WithKind<TBody, "agent">>>, UsedApiFromSource<BuiltContractSource<ClientContractRegistry<TSchemas>, WithKind<TBody, "agent">>>, MergeApis<OwnedApiFromSource<BuiltContractSource<ClientContractRegistry<TSchemas>, WithKind<TBody, "agent">>>, UsedApiFromSource<BuiltContractSource<ClientContractRegistry<TSchemas>, WithKind<TBody, "agent">>>>, TBody["id"], {}, ProjectedState<StateFromSource<BuiltContractSource<ClientContractRegistry<TSchemas>, WithKind<TBody, "agent">>>, SchemasFromSource<BuiltContractSource<ClientContractRegistry<TSchemas>, WithKind<TBody, "agent">>>>>;
-export declare function defineAgentContract<const TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined, const TBody extends ClientContractBodyInput<undefined, TUses>>(build: () => TBody): DefinedContract<OwnedApiFromSource<WithKind<TBody, "agent">>, UsedApiFromSource<WithKind<TBody, "agent">>, MergeApis<OwnedApiFromSource<WithKind<TBody, "agent">>, UsedApiFromSource<WithKind<TBody, "agent">>>, TBody["id"], {}, ProjectedState<StateFromSource<WithKind<TBody, "agent">>, SchemasFromSource<WithKind<TBody, "agent">>>>;
-export declare function defineDeviceContract<const TSchemas extends Readonly<Record<string, TSchema>> | undefined, const TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined, const TBody extends ClientContractBodyInput<TSchemas, TUses>>(registry: ClientContractRegistry<TSchemas> & {
+export declare function defineAgentContract<const TUses extends AuthorContractUses | undefined, const TBody extends ClientContractBodyInput<undefined, TUses>>(build: () => TBody): DefinedContract<OwnedApiFromSource<WithKind<TBody, "agent">>, UsedApiFromSource<WithKind<TBody, "agent">>, MergeApis<OwnedApiFromSource<WithKind<TBody, "agent">>, UsedApiFromSource<WithKind<TBody, "agent">>>, TBody["id"], {}, ProjectedState<StateFromSource<WithKind<TBody, "agent">>, SchemasFromSource<WithKind<TBody, "agent">>>>;
+export declare function defineDeviceContract<const TSchemas extends Readonly<Record<string, TSchema>> | undefined, const TUses extends AuthorContractUses | undefined, const TBody extends ClientContractBodyInput<TSchemas, TUses>>(registry: ClientContractRegistry<TSchemas> & {
+    capabilities?: never;
     exports?: never;
 }, build: (ref: ContractRefBuilder<TSchemas>) => TBody): DefinedContract<OwnedApiFromSource<BuiltContractSource<ClientContractRegistry<TSchemas>, WithKind<TBody, "device">>>, UsedApiFromSource<BuiltContractSource<ClientContractRegistry<TSchemas>, WithKind<TBody, "device">>>, MergeApis<OwnedApiFromSource<BuiltContractSource<ClientContractRegistry<TSchemas>, WithKind<TBody, "device">>>, UsedApiFromSource<BuiltContractSource<ClientContractRegistry<TSchemas>, WithKind<TBody, "device">>>>, TBody["id"], {}, ProjectedState<StateFromSource<BuiltContractSource<ClientContractRegistry<TSchemas>, WithKind<TBody, "device">>>, SchemasFromSource<BuiltContractSource<ClientContractRegistry<TSchemas>, WithKind<TBody, "device">>>>>;
-export declare function defineDeviceContract<const TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined, const TBody extends ClientContractBodyInput<undefined, TUses>>(build: () => TBody): DefinedContract<OwnedApiFromSource<WithKind<TBody, "device">>, UsedApiFromSource<WithKind<TBody, "device">>, MergeApis<OwnedApiFromSource<WithKind<TBody, "device">>, UsedApiFromSource<WithKind<TBody, "device">>>, TBody["id"], {}, ProjectedState<StateFromSource<WithKind<TBody, "device">>, SchemasFromSource<WithKind<TBody, "device">>>>;
-export type { EventDesc, InferRuntimeRpcError, InferSchemaType, JsonValue, RPCDesc, RpcErrorClass, RuntimeRpcErrorDesc, Schema, SchemaLike, SerializableErrorData, TrellisAPI, };
+export declare function defineDeviceContract<const TUses extends AuthorContractUses | undefined, const TBody extends ClientContractBodyInput<undefined, TUses>>(build: () => TBody): DefinedContract<OwnedApiFromSource<WithKind<TBody, "device">>, UsedApiFromSource<WithKind<TBody, "device">>, MergeApis<OwnedApiFromSource<WithKind<TBody, "device">>, UsedApiFromSource<WithKind<TBody, "device">>>, TBody["id"], {}, ProjectedState<StateFromSource<WithKind<TBody, "device">>, SchemasFromSource<WithKind<TBody, "device">>>>;
+export type { EventDesc, FeedDesc, InferRuntimeRpcError, InferSchemaType, JsonValue, RPCDesc, RpcErrorClass, RuntimeRpcErrorDesc, Schema, SchemaLike, SerializableErrorData, TrellisAPI, };
 export { canonicalizeJson, digestJson, isJsonValue, schema, unwrapSchema };
 //# sourceMappingURL=mod.d.ts.map