@qlever-llc/trellis 0.7.0 → 0.8.0-rc.2

package/esm/contract_support/mod.d.ts

@@ -1,12 +1,22 @@
 import { type Static, type TObject, type TProperties, type TSchema } from "typebox";
 import type { BaseError } from "@qlever-llc/result";
-import { TrellisError } from "../errors/TrellisError.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 SubjectDesc, type TransportErrorData, type TrellisAPI, unwrapSchema } from "./runtime.js";
-import { type SubjectParam } from "./schema_pointers.js";
-export { ContractJobQueueResourceSchema, ContractJobsResourceSchema, ContractKvResourceSchema, ContractResourceBindingsSchema, ContractResourcesSchema, ContractSchemaRefSchema, ContractStoreResourceSchema, ContractStreamResourceSchema, type EventHeader, EventHeaderSchema, type InstalledServiceContract, InstalledServiceContractSchema, IsoDateSchema, type JobsQueueBinding, JobsQueueBindingSchema, type JobsResourceBinding, JobsResourceBindingSchema, type KvResourceBinding, KvResourceBindingSchema, type Paginated, PaginatedSchema, type StoreResourceBinding, StoreResourceBindingSchema, type StreamResourceBinding, StreamResourceBindingSchema, } from "./protocol.js";
+import type { AuthMeResponse } from "../auth/protocol.ts";
+import { TrellisError } from "../errors/TrellisError.ts";
+import type { AuthLogoutInput, AuthLogoutResponse } from "../models/auth/rpc/Logout.ts";
+import type { StateDeleteInput, StateDeleteResponse } from "../models/trellis/rpc/StateDelete.ts";
+import type { StateGetInput, StateGetResponse } from "../models/trellis/rpc/StateGet.ts";
+import type { StateListInput, StateListResponse } from "../models/trellis/rpc/StateList.ts";
+import type { StatePutInput, StatePutResponse } from "../models/trellis/rpc/StatePut.ts";
+import { canonicalizeJson, digestJson, isJsonValue, type JsonValue } from "./canonical.ts";
+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.ts";
+import { type SubjectParam } from "./schema_pointers.ts";
+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.ts";
 export declare const CONTRACT_FORMAT_V1: "trellis.contract.v1";
 export declare const CATALOG_FORMAT_V1: "trellis.catalog.v1";
+declare const CONTRACT_MODULE_METADATA: unique symbol;
+export declare const CONTRACT_JOBS_METADATA: unique symbol;
+export declare const CONTRACT_KV_METADATA: unique symbol;
+export declare const CONTRACT_STATE_METADATA: unique symbol;
 type UnionToIntersection<U> = (U extends unknown ? (value: U) => void : never) extends (value: infer I) => void ? I : never;
 type Simplify<T> = {
     [K in keyof T]: T[K];
@@ -18,19 +28,30 @@ export type ContractManifestMetadata = {
     displayName: string;
     description: string;
 };
-export type ContractKind = "service" | "app" | "portal" | "device" | "cli";
+export type ContractKind = "service" | "app" | "device" | "agent";
 export type Capability = string;
 export type JsonSchema = JsonValue | boolean;
 export type ContractSchemaRef<TSchemaName extends string = string> = {
     schema: TSchemaName;
 };
-export type BuiltinContractErrorName = "UnexpectedError" | "AuthError" | "ValidationError" | "KVError" | "StoreError" | "TransferError";
+export type BuiltinContractErrorName = "UnexpectedError" | "TransportError" | "AuthError" | "ValidationError" | "KVError" | "StoreError" | "TransferError";
 type ErrorNameOf<TErrors> = Extract<keyof NonNullable<TErrors>, string> | BuiltinContractErrorName;
 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;
 };
 export type ContractSchemas = Record<string, JsonSchema>;
+export type ContractExports<TSchemaName extends string = string> = {
+    schemas?: TSchemaName[];
+};
+export type ContractStateKind = "value" | "map";
+export type ContractStateStore = {
+    kind: ContractStateKind;
+    schema: ContractSchemaRef;
+    stateVersion?: string;
+    acceptedVersions?: Record<string, ContractSchemaRef>;
+};
+export type ContractState = Record<string, ContractStateStore>;
 type ContractIdentityFields = {
     id: string;
     displayName: string;
@@ -48,6 +69,9 @@ export type ContractRpcMethod = {
     subject: string;
     input: ContractSchemaRef;
     output: ContractSchemaRef;
+    transfer?: {
+        direction: "receive";
+    };
     capabilities?: {
         call?: Capability[];
     };
@@ -58,8 +82,9 @@ export type ContractOperation = {
     subject: string;
     input: ContractSchemaRef;
     progress?: ContractSchemaRef;
-    output?: ContractSchemaRef;
+    output: ContractSchemaRef;
     transfer?: {
+        direction: "send";
         store: string;
         key: `/${string}`;
         contentType?: `/${string}`;
@@ -84,14 +109,6 @@ export type ContractEvent = {
         subscribe?: Capability[];
     };
 };
-export type ContractSubject = {
-    subject: string;
-    message?: ContractSchemaRef;
-    capabilities?: {
-        publish?: Capability[];
-        subscribe?: Capability[];
-    };
-};
 export type ContractJobQueueResource = {
     payload: ContractSchemaRef;
     result?: ContractSchemaRef;
@@ -104,11 +121,11 @@ export type ContractJobQueueResource = {
     dlq?: boolean;
     concurrency?: number;
 };
-export type ContractJobsResource = {
-    queues: Record<string, ContractJobQueueResource>;
-};
+export type ContractJobQueue = ContractJobQueueResource;
+export type ContractJobs = Record<string, ContractJobQueue>;
 export type ContractKvResource = {
     purpose: string;
+    schema: ContractSchemaRef;
     required?: boolean;
     history?: number;
     ttlMs?: number;
@@ -121,28 +138,9 @@ export type ContractStoreResource = {
     maxObjectBytes?: number;
     maxTotalBytes?: number;
 };
-export type ContractStreamResource = {
-    purpose: string;
-    required?: boolean;
-    retention?: "limits" | "interest" | "workqueue";
-    storage?: "file" | "memory";
-    numReplicas?: number;
-    maxAgeMs?: number;
-    maxBytes?: number;
-    maxMsgs?: number;
-    discard?: "old" | "new";
-    subjects: string[];
-    sources?: Array<{
-        fromAlias: string;
-        filterSubject?: string;
-        subjectTransformDest?: string;
-    }>;
-};
 export type ContractResources = {
     kv?: Record<string, ContractKvResource>;
     store?: Record<string, ContractStoreResource>;
-    streams?: Record<string, ContractStreamResource>;
-    jobs?: ContractJobsResource;
 };
 export type ContractUsesRpc = {
     call?: string[];
@@ -156,7 +154,6 @@ export type ContractUse = {
     rpc?: ContractUsesRpc;
     operations?: ContractUsesRpc;
     events?: ContractUsesPubSub;
-    subjects?: ContractUsesPubSub;
 };
 export type ContractUses = Record<string, ContractUse>;
 export type TrellisContractV1 = {
@@ -166,12 +163,14 @@ export type TrellisContractV1 = {
     description: string;
     kind: ContractKind;
     schemas?: ContractSchemas;
+    exports?: ContractExports;
+    state?: ContractState;
     uses?: ContractUses;
     rpc?: Record<string, ContractRpcMethod>;
     operations?: Record<string, ContractOperation>;
     events?: Record<string, ContractEvent>;
-    subjects?: Record<string, ContractSubject>;
     errors?: Record<string, ContractErrorDecl>;
+    jobs?: ContractJobs;
     resources?: ContractResources;
 };
 export type TrellisCatalogEntry = {
@@ -191,13 +190,13 @@ export type ContractSourceErrorDecl<TSchemaName extends string = string> = {
 type ExtractErrorClasses<TErrors> = TErrors extends Readonly<Record<string, unknown>> ? {
     [K in keyof TErrors as TErrors[K] extends ErrorClass ? K : never]: Extract<TErrors[K], ErrorClass>;
 } : undefined;
-export type ErrorClass<TData extends TransportErrorData = TransportErrorData, TError extends BaseError = BaseError, TRuntimeSchema extends TSchema = TSchema> = RpcErrorClass<TData, TError> & {
+export type ErrorClass<TData extends SerializableErrorData = SerializableErrorData, TError extends BaseError = BaseError, TRuntimeSchema extends TSchema = TSchema> = RpcErrorClass<TData, TError> & {
     readonly name: string;
     readonly schema: TRuntimeSchema;
     readonly type?: string;
 };
 type DefinedErrorPayload<TFields extends TProperties> = Static<TObject<TFields>> & object;
-type DefinedErrorData<TType extends string, TFields extends TProperties> = TransportErrorData & {
+type DefinedErrorData<TType extends string, TFields extends TProperties> = SerializableErrorData & {
     type: TType;
 } & DefinedErrorPayload<TFields>;
 type DefinedErrorSchema = TObject<TProperties>;
@@ -222,6 +221,16 @@ export type DefinedErrorClass<TType extends string, TFields extends TProperties>
     fromSerializable(data: DefinedErrorData<TType, TFields>): DefinedErrorInstance<TType, TFields>;
 };
 export type ContractSourceSchemas = Record<string, TSchema>;
+export type ContractSourceExports<TSchemaName extends string = string> = {
+    schemas?: readonly TSchemaName[];
+};
+export type ContractSourceStateStore<TSchemaName extends string = string> = {
+    kind: ContractStateKind;
+    schema: ContractSchemaRef<TSchemaName>;
+    stateVersion?: 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> = {
     version: `v${number}`;
     input: ContractSchemaRef<TSchemaName>;
@@ -229,6 +238,9 @@ export type ContractSourceRpcMethod<TSchemaName extends string = string, TErrorN
     capabilities?: {
         call?: readonly Capability[];
     };
+    transfer?: {
+        direction: "receive";
+    };
     errors?: readonly TErrorName[];
     authRequired?: boolean;
     subject?: string;
@@ -237,8 +249,9 @@ export type ContractSourceOperation<TSchemaName extends string = string> = {
     version: `v${number}`;
     input: ContractSchemaRef<TSchemaName>;
     progress?: ContractSchemaRef<TSchemaName>;
-    output?: ContractSchemaRef<TSchemaName>;
+    output: ContractSchemaRef<TSchemaName>;
     transfer?: {
+        direction: "send";
         store: string;
         key: `/${string}`;
         contentType?: `/${string}`;
@@ -264,15 +277,7 @@ export type ContractSourceEvent<TSchemaName extends string = string> = {
     };
     subject?: string;
 };
-export type ContractSourceSubject<TSchemaName extends string = string> = {
-    subject: string;
-    message?: ContractSchemaRef<TSchemaName>;
-    capabilities?: {
-        publish?: readonly Capability[];
-        subscribe?: readonly Capability[];
-    };
-};
-export type ContractSourceJobQueueResource<TSchemaName extends string = string> = {
+export type ContractSourceJobQueue<TSchemaName extends string = string> = {
     payload: ContractSchemaRef<TSchemaName>;
     result?: ContractSchemaRef<TSchemaName>;
     maxDeliver?: number;
@@ -284,11 +289,10 @@ export type ContractSourceJobQueueResource<TSchemaName extends string = string>
     dlq?: boolean;
     concurrency?: number;
 };
-export type ContractSourceJobsResource<TSchemaName extends string = string> = {
-    queues: Record<string, ContractSourceJobQueueResource<TSchemaName>>;
-};
-export type ContractSourceKvResource = {
+export type ContractSourceJobs<TSchemaName extends string = string> = Record<string, ContractSourceJobQueue<TSchemaName>>;
+export type ContractSourceKvResource<TSchemaName extends string = string> = {
     purpose: string;
+    schema: ContractSchemaRef<TSchemaName>;
     required?: boolean;
     history?: number;
     ttlMs?: number;
@@ -301,28 +305,9 @@ export type ContractSourceStoreResource = {
     maxObjectBytes?: number;
     maxTotalBytes?: number;
 };
-export type ContractSourceStreamResource = {
-    purpose: string;
-    required?: boolean;
-    subjects: readonly string[];
-    retention?: "limits" | "interest" | "workqueue";
-    storage?: "file" | "memory";
-    numReplicas?: number;
-    maxAgeMs?: number;
-    maxBytes?: number;
-    maxMsgs?: number;
-    discard?: "old" | "new";
-    sources?: ReadonlyArray<{
-        fromAlias: string;
-        filterSubject?: string;
-        subjectTransformDest?: string;
-    }>;
-};
 export type ContractSourceResources<TSchemaName extends string = string> = {
-    kv?: Record<string, ContractSourceKvResource>;
+    kv?: Record<string, ContractSourceKvResource<TSchemaName>>;
     store?: Record<string, ContractSourceStoreResource>;
-    streams?: Record<string, ContractSourceStreamResource>;
-    jobs?: ContractSourceJobsResource<TSchemaName>;
 };
 export type ContractSourceUse = {
     contract: string;
@@ -336,10 +321,6 @@ export type ContractSourceUse = {
         publish?: readonly string[];
         subscribe?: readonly string[];
     };
-    subjects?: {
-        publish?: readonly string[];
-        subscribe?: readonly string[];
-    };
 };
 export type TrellisContractSource = {
     id: string;
@@ -347,19 +328,21 @@ export type TrellisContractSource = {
     description: string;
     kind: ContractKind;
     schemas?: ContractSourceSchemas;
+    exports?: ContractSourceExports;
+    state?: ContractSourceState;
     uses?: Record<string, ContractSourceUse>;
     rpc?: Record<string, ContractSourceRpcMethod>;
     operations?: Record<string, ContractSourceOperation>;
     events?: Record<string, ContractSourceEvent>;
-    subjects?: Record<string, ContractSourceSubject>;
     errors?: Record<string, ContractSourceErrorDecl>;
+    jobs?: ContractSourceJobs;
     resources?: ContractSourceResources;
 };
 export type TrellisApiLike = {
     rpc: Record<string, RPCDesc>;
     operations: Record<string, OperationDesc>;
     events: Record<string, EventDesc>;
-    subjects: Record<string, SubjectDesc>;
+    subjects: Record<string, unknown>;
 };
 type ApiShape = {
     rpc: Record<string, unknown>;
@@ -373,6 +356,26 @@ export type EmptyApi = {
     events: {};
     subjects: {};
 };
+type BaselineAuthApi = {
+    rpc: {
+        "Auth.Me": RPCDesc<Schema<Record<string, never>>, Schema<AuthMeResponse>>;
+        "Auth.Logout": RPCDesc<Schema<AuthLogoutInput>, Schema<AuthLogoutResponse>>;
+    };
+    operations: {};
+    events: {};
+    subjects: {};
+};
+type BaselineStateApi = {
+    rpc: {
+        "State.Get": RPCDesc<Schema<StateGetInput>, Schema<StateGetResponse>>;
+        "State.Put": RPCDesc<Schema<StatePutInput>, Schema<StatePutResponse>>;
+        "State.Delete": RPCDesc<Schema<StateDeleteInput>, Schema<StateDeleteResponse>>;
+        "State.List": RPCDesc<Schema<StateListInput>, Schema<StateListResponse>>;
+    };
+    operations: {};
+    events: {};
+    subjects: {};
+};
 export type ContractApiViews<TOwnedApi extends ApiShape, TUsedApi extends ApiShape, TTrellisApi extends ApiShape> = {
     owned: TOwnedApi;
     used: TUsedApi;
@@ -389,43 +392,30 @@ export type UseSpec<TApi extends ApiShape> = {
         publish?: readonly StringKeyOf<TApi["events"]>[];
         subscribe?: readonly StringKeyOf<TApi["events"]>[];
     };
-    subjects?: {
-        publish?: readonly StringKeyOf<TApi["subjects"]>[];
-        subscribe?: readonly StringKeyOf<TApi["subjects"]>[];
-    };
 };
 type UseRpcCall<TSpec> = NonNullable<TSpec extends {
     rpc?: infer TRpc;
 } ? TRpc : never> extends {
-    call?: infer TCall;
+    call?: infer TCall extends readonly string[] | undefined;
 } ? TCall : never;
 type UseEventsPublish<TSpec> = NonNullable<TSpec extends {
     events?: infer TEvents;
 } ? TEvents : never> extends {
-    publish?: infer TPublish;
+    publish?: infer TPublish extends readonly string[] | undefined;
 } ? TPublish : never;
 type UseOperationsCall<TSpec> = NonNullable<TSpec extends {
     operations?: infer TOperations;
 } ? TOperations : never> extends {
-    call?: infer TCall;
+    call?: infer TCall extends readonly string[] | undefined;
 } ? TCall : never;
 type UseEventsSubscribe<TSpec> = NonNullable<TSpec extends {
     events?: infer TEvents;
 } ? TEvents : never> extends {
-    subscribe?: infer TSubscribe;
-} ? TSubscribe : never;
-type UseSubjectsPublish<TSpec> = NonNullable<TSpec extends {
-    subjects?: infer TSubjects;
-} ? TSubjects : never> extends {
-    publish?: infer TPublish;
-} ? TPublish : never;
-type UseSubjectsSubscribe<TSpec> = NonNullable<TSpec extends {
-    subjects?: infer TSubjects;
-} ? TSubjects : never> extends {
-    subscribe?: infer TSubscribe;
+    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>;
     rpc?: {
         call?: UseRpcCall<TSpec>;
     };
@@ -436,33 +426,83 @@ export type ContractDependencyUse<TContractId extends string, TApi extends ApiSh
         publish?: UseEventsPublish<TSpec>;
         subscribe?: UseEventsSubscribe<TSpec>;
     };
-    subjects?: {
-        publish?: UseSubjectsPublish<TSpec>;
-        subscribe?: UseSubjectsSubscribe<TSpec>;
-    };
 };
-type AuthorContractDependencyUse = ContractDependencyUse<string, TrellisApiLike, any>;
-export type ContractUseFn<TContractId extends string, TApi extends ApiShape> = <const TRpcCall extends readonly StringKeyOf<TApi["rpc"]>[] | undefined = undefined, const TOperationsCall extends readonly StringKeyOf<TApi["operations"]>[] | undefined = undefined, const TEventsPublish extends readonly StringKeyOf<TApi["events"]>[] | undefined = undefined, const TEventsSubscribe extends readonly StringKeyOf<TApi["events"]>[] | undefined = undefined, const TSubjectsPublish extends readonly StringKeyOf<TApi["subjects"]>[] | undefined = undefined, const TSubjectsSubscribe extends readonly StringKeyOf<TApi["subjects"]>[] | undefined = undefined>(spec: {
-    rpc?: {
-        call?: TRpcCall;
-    };
-    operations?: {
-        call?: TOperationsCall;
-    };
-    events?: {
-        publish?: TEventsPublish;
-        subscribe?: TEventsSubscribe;
-    };
-    subjects?: {
-        publish?: TSubjectsPublish;
-        subscribe?: TSubjectsSubscribe;
-    };
-}) => ContractDependencyUse<TContractId, TApi>;
+type AuthorContractDependencyUse = ContractDependencyUse<string, ApiShape, UseSpec<ApiShape>>;
+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>;
 type ResolveSchemaFromMap<TSchemas, TRef> = TRef extends {
     schema: infer TName;
-} ? TName extends SchemaNameOf<TSchemas> ? NonNullable<TSchemas>[TName] extends TSchema ? Schema<import("./runtime.js").InferSchemaType<NonNullable<TSchemas>[TName]>> : Schema<unknown> : Schema<unknown> : Schema<unknown>;
+} ? TName extends SchemaNameOf<TSchemas> ? NonNullable<TSchemas>[TName] extends TSchema ? Schema<import("./runtime.ts").InferSchemaType<NonNullable<TSchemas>[TName]>> : Schema<unknown> : Schema<unknown> : Schema<unknown>;
+type ResolveSchemaTypeFromMap<TSchemas, TRef> = TRef extends {
+    schema: infer TName;
+} ? TName extends SchemaNameOf<TSchemas> ? NonNullable<TSchemas>[TName] extends TSchema ? InferSchemaType<NonNullable<TSchemas>[TName]> : unknown : unknown : unknown;
+export type ContractJobsMetadata = Record<string, {
+    payload: unknown;
+    result: unknown;
+}>;
+export type ContractKvMetadata = Record<string, {
+    required: boolean;
+    value: unknown;
+    schema: TSchema;
+}>;
+export type ContractStateMetadata = Record<string, {
+    kind: ContractStateKind;
+    value: unknown;
+    schema: unknown;
+    stateVersion: string;
+    acceptedVersions: Record<string, unknown>;
+}>;
+type ResolveTypeBoxSchemaFromMap<TSchemas, TRef> = TRef extends {
+    schema: infer TName;
+} ? TName extends SchemaNameOf<TSchemas> ? NonNullable<TSchemas>[TName] extends TSchema ? NonNullable<TSchemas>[TName] : TSchema : TSchema : TSchema;
+type ProjectedJobs<T extends ContractSourceJobs<string> | undefined, TSchemas> = T extends ContractSourceJobs<string> ? {
+    [K in keyof T]: {
+        payload: ResolveSchemaTypeFromMap<TSchemas, T[K]["payload"]>;
+        result: ResolveSchemaTypeFromMap<TSchemas, T[K]["result"]>;
+    };
+} : {};
+type ProjectedState<T extends ContractSourceState<string> | undefined, TSchemas> = T extends ContractSourceState<string> ? {
+    [K in keyof T]: T[K] extends {
+        kind: infer TKind extends ContractStateKind;
+    } ? {
+        kind: TKind;
+        value: ResolveSchemaTypeFromMap<TSchemas, T[K]["schema"]>;
+        schema: unknown;
+        stateVersion: T[K] extends {
+            stateVersion: infer TVersion extends string;
+        } ? TVersion : "v1";
+        acceptedVersions: T[K] extends {
+            acceptedVersions: infer TVersions;
+        } ? TVersions : {};
+    } : never;
+} : {};
+type ProjectedKvResources<T extends ContractSourceResources<string> | undefined, TSchemas> = T extends {
+    kv?: infer TKv;
+} ? TKv extends Record<string, {
+    schema: ContractSchemaRef<string>;
+    required?: boolean;
+}> ? {
+    [K in keyof TKv]: {
+        required: TKv[K] extends {
+            required: infer TRequired extends boolean;
+        } ? TRequired : true;
+        value: ResolveSchemaTypeFromMap<TSchemas, TKv[K]["schema"]>;
+        schema: ResolveTypeBoxSchemaFromMap<TSchemas, TKv[K]["schema"]>;
+    };
+} : {} : {};
+type JobsFromSource<T> = T extends {
+    jobs?: infer TJobs;
+} ? Extract<TJobs, ContractSourceJobs<string> | undefined> : undefined;
+type ResourcesFromSource<T> = T extends {
+    resources?: infer TResources;
+} ? Extract<TResources, ContractSourceResources<string> | undefined> : undefined;
+type StateFromSource<T> = T extends {
+    state?: infer TState;
+} ? Extract<TState, ContractSourceState<string> | undefined> : undefined;
+type SchemasFromSource<T> = T extends {
+    schemas?: infer TSchemas;
+} ? TSchemas : undefined;
 type ProjectedRpcMethod<TMethod extends ContractSourceRpcMethod, TSchemas, _TErrors> = {
     subject: string;
     input: ResolveSchemaFromMap<TSchemas, TMethod["input"]>;
@@ -472,7 +512,11 @@ type ProjectedRpcMethod<TMethod extends ContractSourceRpcMethod, TSchemas, _TErr
     errors?: TMethod["errors"];
     runtimeErrors?: readonly RuntimeRpcErrorDesc[];
     declaredErrorTypes?: readonly string[];
-};
+} & (TMethod extends {
+    transfer: infer TTransfer;
+} ? {
+    transfer: TTransfer;
+} : {});
 type ProjectedRpc<T extends Readonly<Record<string, ContractSourceRpcMethod>> | undefined, TSchemas, TErrors> = T extends Readonly<Record<string, ContractSourceRpcMethod>> ? {
     [K in keyof T]: ProjectedRpcMethod<T[K], TSchemas, TErrors>;
 } : {};
@@ -484,21 +528,17 @@ type ProjectedOperations<T extends Readonly<Record<string, ContractSourceOperati
 type ProjectedEvents<T extends Readonly<Record<string, ContractSourceEvent>> | undefined, TSchemas> = T extends Readonly<Record<string, ContractSourceEvent>> ? {
     [K in keyof T]: EventDesc<ResolveSchemaFromMap<TSchemas, T[K]["event"]>>;
 } : {};
-type ProjectedSubjects<T extends Readonly<Record<string, ContractSourceSubject>> | undefined, TSchemas> = T extends Readonly<Record<string, ContractSourceSubject>> ? {
-    [K in keyof T]: SubjectDesc<ResolveSchemaFromMap<TSchemas, T[K]["message"]>>;
-} : {};
 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>>;
-    subjects?: Readonly<Record<string, ContractSourceSubject>>;
 }> = {
     rpc: ProjectedRpc<T["rpc"], T["schemas"], T["errors"]>;
     operations: ProjectedOperations<T["operations"], T["schemas"]>;
     events: ProjectedEvents<T["events"], T["schemas"]>;
-    subjects: ProjectedSubjects<T["subjects"], T["schemas"]>;
+    subjects: {};
 };
 type RpcKeysFromSpec<TSpec> = TSpec extends {
     rpc?: {
@@ -519,20 +559,11 @@ type OperationKeysFromSpec<TSpec> = TSpec extends {
         call?: infer TCall;
     };
 } ? KeysFromList<TCall> : never;
-type SubjectKeysFromSpec<TSpec> = (TSpec extends {
-    subjects?: {
-        publish?: infer TPublish;
-    };
-} ? KeysFromList<TPublish> : never) | (TSpec extends {
-    subjects?: {
-        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>>;
-    subjects: Pick<TApi["subjects"], SubjectKeysFromSpec<TSpec>>;
+    subjects: {};
 } : EmptyApi;
 export type UsedApiFromUses<TUses> = [TUses] extends [undefined] ? EmptyApi : TUses extends Record<string, unknown> ? {
     rpc: MergeRecordUnion<ApiFromDependencyUse<TUses[keyof TUses]>["rpc"]>;
@@ -540,38 +571,57 @@ export type UsedApiFromUses<TUses> = [TUses] extends [undefined] ? EmptyApi : TU
     events: MergeRecordUnion<ApiFromDependencyUse<TUses[keyof TUses]>["events"]>;
     subjects: MergeRecordUnion<ApiFromDependencyUse<TUses[keyof TUses]>["subjects"]>;
 } : EmptyApi;
+type ImplicitAuthApiForKind<TKind> = TKind extends "app" | "agent" | "device" ? BaselineAuthApi : EmptyApi;
+type ImplicitStateApiForSource<T> = [StateFromSource<T>] extends [undefined] ? EmptyApi : BaselineStateApi;
+type ImplicitTrellisApiFromSource<T> = T extends {
+    kind: infer TKind;
+} ? MergeApis<ImplicitAuthApiForKind<TKind>, ImplicitStateApiForSource<T>> : EmptyApi;
+export type UsedApiFromSource<T extends {
+    uses?: unknown;
+}> = MergeApis<UsedApiFromUses<T["uses"]>, ImplicitTrellisApiFromSource<T>>;
 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"]>;
     subjects: Simplify<TUsedApi["subjects"] & TOwnedApi["subjects"]>;
 };
-export type ContractModule<TContractId extends string, TOwnedApi extends ApiShape, TUsedApi extends ApiShape, TTrellisApi extends ApiShape> = {
+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> = {
     CONTRACT_ID: TContractId;
     CONTRACT: TrellisContractV1;
     CONTRACT_DIGEST: string;
     API: ContractApiViews<TOwnedApi, TUsedApi, TTrellisApi>;
     use: ContractUseFn<TContractId, TOwnedApi>;
+    readonly [CONTRACT_JOBS_METADATA]?: TJobs;
+    readonly [CONTRACT_STATE_METADATA]?: TState;
+    readonly [CONTRACT_KV_METADATA]?: TKv;
 };
-export type SdkContractModule<TContractId extends string, TOwnedApi extends ApiShape> = ContractModule<TContractId, TOwnedApi, EmptyApi, TOwnedApi>;
-export type DefinedContract<TOwnedApi extends ApiShape, TUsedApi extends ApiShape, TTrellisApi extends ApiShape, TContractId extends string = string> = ContractModule<TContractId, TOwnedApi, TUsedApi, TTrellisApi>;
-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, TSubjects extends Readonly<Record<string, ContractSourceSubject<SchemaNameOf<TSchemas>>>> | undefined = undefined> = {
+export type SdkContractModule<TContractId extends string, TOwnedApi extends ApiShape, TJobs extends ContractJobsMetadata = {}, TState extends ContractStateMetadata = {}, TKv extends ContractKvMetadata = ContractKvMetadata> = Omit<ContractModule<TContractId, TOwnedApi, EmptyApi, TOwnedApi, TJobs, TState, TKv>, "use"> & {
+    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> = {
     id: string;
     displayName: string;
     description: string;
     kind: ContractKind;
     schemas?: TSchemas;
+    exports?: ContractSourceExports<SchemaNameOf<TSchemas>>;
+    state?: ContractSourceState<SchemaNameOf<TSchemas>>;
     uses?: TUses;
     errors?: TErrors;
     rpc?: TRpc;
     operations?: TOperations;
     events?: TEvents;
-    subjects?: TSubjects;
+    jobs?: ContractSourceJobs<SchemaNameOf<TSchemas>>;
     resources?: ContractSourceResources<SchemaNameOf<TSchemas>>;
 };
-type AnyDefineContractRegistry = {
-    schemas?: Readonly<Record<string, TSchema>>;
-    errors?: Readonly<Record<string, unknown>>;
+type DefineContractRegistry<TSchemas extends Readonly<Record<string, TSchema>> | undefined = undefined, TErrors extends Readonly<Record<string, unknown>> | undefined = undefined> = {
+    schemas?: TSchemas;
+    errors?: TErrors;
+};
+type AnyDefineContractRegistry = DefineContractRegistry<Readonly<Record<string, TSchema>> | undefined, Readonly<Record<string, unknown>> | undefined>;
+type ClientContractRegistry<TSchemas extends Readonly<Record<string, TSchema>> | undefined = undefined> = {
+    schemas?: TSchemas;
 };
 type RegistrySchemas<TRegistry extends AnyDefineContractRegistry> = TRegistry extends {
     schemas?: infer TSchemas;
@@ -579,14 +629,17 @@ 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, TSubjects extends Readonly<Record<string, ContractSourceSubject<SchemaNameOf<TSchemas>>>> | undefined = undefined> = Omit<DefineContractInput<TSchemas, TUses, TErrors, TRpc, TOperations, TEvents, TSubjects>, "schemas" | "errors"> & {
+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"> & {
     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, TSubjects extends Readonly<Record<string, ContractSourceSubject<SchemaNameOf<TSchemas>>>> | undefined = undefined> = Omit<DefineContractBodyInput<TSchemas, TUses, TErrors, TRpc, TOperations, TEvents, TSubjects>, "kind"> & {
+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"> & {
     kind?: never;
+    subjects?: never;
 };
-type ClientContractBodyInput<TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined = undefined> = ContractIdentityFields & {
+type ClientContractBodyInput<TSchemas extends Readonly<Record<string, TSchema>> | undefined = undefined, TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined = undefined> = ContractIdentityFields & {
+    exports?: ContractSourceExports<SchemaNameOf<TSchemas>>;
+    state?: ContractSourceState<SchemaNameOf<TSchemas>>;
     uses?: TUses;
     kind?: never;
     schemas?: never;
@@ -605,6 +658,12 @@ type WithKind<TBody extends {
 }, TKind extends ContractKind> = Simplify<Omit<TBody, "kind"> & {
     kind: TKind;
 }>;
+/**
+ * Build the normalized runtime/interface projection used for contract identity.
+ */
+export declare function projectContractDigestManifest(contract: TrellisContractV1): JsonValue;
+/** Compute the v1 contract digest from the normalized digest projection. */
+export declare function digestContractManifest(contract: TrellisContractV1): string;
 /**
  * Define a transportable Trellis error class from a payload-object schema.
  *
@@ -612,11 +671,21 @@ type WithKind<TBody extends {
  * 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 TRegistry extends AnyDefineContractRegistry, 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 TSubjects extends Readonly<Record<string, ContractSourceSubject<SchemaNameOf<RegistrySchemas<TRegistry>>>>> | undefined, const TBody extends ServiceContractBodyInput<RegistrySchemas<TRegistry>, TUses, RegistryErrors<TRegistry>, TRpc, TOperations, TEvents, TSubjects>>(registry: TRegistry, build: (ref: ContractRefBuilder<RegistrySchemas<TRegistry>, RegistryErrors<TRegistry>>) => TBody): DefinedContract<OwnedApiFromSource<BuiltContractSource<TRegistry, WithKind<TBody, "service">>>, UsedApiFromUses<TBody["uses"]>, MergeApis<OwnedApiFromSource<BuiltContractSource<TRegistry, WithKind<TBody, "service">>>, UsedApiFromUses<TBody["uses"]>>, TBody["id"]>;
-export declare function defineAppContract<const TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined, const TBody extends ClientContractBodyInput<TUses>>(build: () => TBody): DefinedContract<OwnedApiFromSource<WithKind<TBody, "app">>, UsedApiFromUses<TBody["uses"]>, MergeApis<OwnedApiFromSource<WithKind<TBody, "app">>, UsedApiFromUses<TBody["uses"]>>, TBody["id"]>;
-export declare function definePortalContract<const TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined, const TBody extends ClientContractBodyInput<TUses>>(build: () => TBody): DefinedContract<OwnedApiFromSource<WithKind<TBody, "portal">>, UsedApiFromUses<TBody["uses"]>, MergeApis<OwnedApiFromSource<WithKind<TBody, "portal">>, UsedApiFromUses<TBody["uses"]>>, TBody["id"]>;
-export declare function defineCliContract<const TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined, const TBody extends ClientContractBodyInput<TUses>>(build: () => TBody): DefinedContract<OwnedApiFromSource<WithKind<TBody, "cli">>, UsedApiFromUses<TBody["uses"]>, MergeApis<OwnedApiFromSource<WithKind<TBody, "cli">>, UsedApiFromUses<TBody["uses"]>>, TBody["id"]>;
-export declare function defineDeviceContract<const TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined, const TBody extends ClientContractBodyInput<TUses>>(build: () => TBody): DefinedContract<OwnedApiFromSource<WithKind<TBody, "device">>, UsedApiFromUses<TBody["uses"]>, MergeApis<OwnedApiFromSource<WithKind<TBody, "device">>, UsedApiFromUses<TBody["uses"]>>, TBody["id"]>;
-export type { EventDesc, InferRuntimeRpcError, InferSchemaType, JsonValue, RPCDesc, RpcErrorClass, RuntimeRpcErrorDesc, Schema, SchemaLike, SubjectDesc, TransportErrorData, TrellisAPI, };
+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 & {
+    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> & {
+    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> & {
+    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> & {
+    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 { canonicalizeJson, digestJson, isJsonValue, schema, unwrapSchema };
 //# sourceMappingURL=mod.d.ts.map