@qlever-llc/trellis 0.10.4 → 0.10.7

package/script/trellis.js

@@ -295,6 +295,26 @@ function isTerminalRuntimeOperationSnapshot(value) {
     return isRuntimeOperationSnapshot(value) && (value.state === "completed" || value.state === "failed" ||
         value.state === "cancelled");
 }
+function createEventListenerContext(args) {
+    const header = typeof args.payload === "object" && args.payload !== null
+        ? Reflect.get(args.payload, "header")
+        : undefined;
+    const id = typeof header === "object" && header !== null
+        ? Reflect.get(header, "id")
+        : undefined;
+    const time = typeof header === "object" && header !== null
+        ? Reflect.get(header, "time")
+        : undefined;
+    const sequence = Reflect.get(args.message, "seq");
+    return {
+        id: typeof id === "string" ? id : "",
+        time: new Date(typeof time === "string" ? time : 0),
+        subject: args.subject,
+        mode: args.mode,
+        ...(args.group ? { group: args.group } : {}),
+        ...(typeof sequence === "number" ? { sequence } : {}),
+    };
+}
 let pendingInternalEventConsumers;
 /**
  * Creates a Trellis runtime with bootstrap-resolved bindings.
@@ -1931,7 +1951,12 @@ _Trellis_log = new WeakMap(), _Trellis_tasks = new WeakMap(), _Trellis_hasExplic
                 __classPrivateFieldGet(this, _Trellis_log, "f").error({ error: m.error }, "Event validation failed");
                 continue;
             }
-            const handlerResult = await result_1.AsyncResult.lift(fn(m));
+            const handlerResult = await result_1.AsyncResult.lift(fn(m, createEventListenerContext({
+                payload: m,
+                subject: msg.subject,
+                mode: "ephemeral",
+                message: msg,
+            })));
             if (handlerResult.isErr()) {
                 __classPrivateFieldGet(this, _Trellis_log, "f").error({
                     error: handlerResult.error.toSerializable(),
@@ -2068,7 +2093,12 @@ _Trellis_log = new WeakMap(), _Trellis_tasks = new WeakMap(), _Trellis_hasExplic
                 msg.term();
                 continue;
             }
-            const handlerResult = await result_1.AsyncResult.lift(fn(m));
+            const handlerResult = await result_1.AsyncResult.lift(fn(m, createEventListenerContext({
+                payload: m,
+                subject: msg.subject,
+                mode: "durable",
+                message: msg,
+            })));
             if (handlerResult.isErr()) {
                 __classPrivateFieldGet(this, _Trellis_log, "f").error({
                     error: handlerResult.error.toSerializable(),
@@ -2104,7 +2134,13 @@ _Trellis_log = new WeakMap(), _Trellis_tasks = new WeakMap(), _Trellis_hasExplic
                     failed = true;
                     break;
                 }
-                const handlerResult = await result_1.AsyncResult.lift(registration.fn(eventPayload));
+                const handlerResult = await result_1.AsyncResult.lift(registration.fn(eventPayload, createEventListenerContext({
+                    payload: eventPayload,
+                    subject: msg.subject,
+                    mode: "durable",
+                    group,
+                    message: msg,
+                })));
                 if (handlerResult.isErr()) {
                     __classPrivateFieldGet(this, _Trellis_log, "f").error({
                         error: handlerResult.error.toSerializable(),

package/src/index.ts

@@ -200,6 +200,7 @@ export type {
   ClientTrellis,
   ConnectedTrellisClient,
   EventHandler,
+  EventListenerContext,
   EventName,
   EventOpts,
   EventPayload,

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

@@ -1,13 +1,21 @@
 // Generated from ./generated/contracts/manifests/trellis.auth@v1.json
-import type { AcceptedOperation, AsyncResult, BaseError, EventOpts, FeedSubscribeOpts, FeedSubscription, HandlerTrellis, MapStateStoreClient, MaybeAsync, OperationInputBuilder, OperationObserverCallbacks, OperationRef, OperationRefData, OperationRuntimeHandle, PreparedTrellisEvent, ReceiveTransferGrant, ReceiveTransferHandle, RequestOpts, Result, RpcHandlerContext, SendTransferGrant, SendTransferHandle, TerminalOperation, TransferCapableOperationInputBuilder, TrellisConnection, UnexpectedError, ValidationError, ValueStateStoreClient } from "../../../index.js";
+import type { AcceptedOperation, AsyncResult, BaseError, EventListenerContext, EventOpts, FeedSubscribeOpts, FeedSubscription, HandlerTrellis, MapStateStoreClient, MaybeAsync, OperationInputBuilder, OperationObserverCallbacks, OperationRef, OperationRefData, OperationRuntimeHandle, OperationTransferHandle, PreparedTrellisEvent, ReceiveTransferGrant, ReceiveTransferHandle, RequestOpts, Result, RpcHandlerContext, SendTransferGrant, SendTransferHandle, TerminalOperation, TransferCapableOperationInputBuilder, TrellisConnection, UnexpectedError, ValidationError, ValueStateStoreClient } from "../../../index.js";
 import type { API, Api } from "./api.js";
 import type * as Types from "./types.js";
 
+type WithDeps<TDeps> = [TDeps] extends [undefined] ? {} : { deps: TDeps };
+
 type EventCallback<TMessage> = {
-  bivarianceHack(message: TMessage): MaybeAsync<void, BaseError>;
+  bivarianceHack(message: TMessage, context: EventListenerContext): MaybeAsync<void, BaseError>;
 }["bivarianceHack"];
 
-type RpcHandler<TInput, TOutput> = (args: { input: TInput; context: RpcHandlerContext; client: HandlerClient }) => MaybeAsync<TOutput, BaseError>;
+type ServiceEventHandler<TEvent, TDeps = undefined> = (args: { event: TEvent; context: EventListenerContext; client: HandlerClient } & WithDeps<TDeps>) => MaybeAsync<void, BaseError>;
+
+type RpcHandler<TInput, TOutput, TDeps = undefined> = (args: { input: TInput; context: RpcHandlerContext; client: HandlerClient } & WithDeps<TDeps>) => MaybeAsync<TOutput, BaseError>;
+
+type FeedHandler<TInput, TEvent, TDeps = undefined> = (context: { input: TInput; caller: unknown; signal: AbortSignal; emit(event: TEvent): AsyncResult<void, ValidationError | UnexpectedError>; client: HandlerClient } & WithDeps<TDeps>) => unknown | Promise<unknown>;
+
+type OperationHandler<TInput, TProgress, TOutput, TTransfer, TDeps = undefined> = (context: { input: TInput; op: OperationRuntimeHandle<TProgress, TOutput>; caller: unknown; client: HandlerClient } & TTransfer & WithDeps<TDeps>) => unknown | Promise<unknown>;
 
 export type TrellisAuthState = {};
 
@@ -120,85 +128,105 @@ export interface TrellisAuthClient {
   wait(): AsyncResult<void, BaseError>;
 }
 
-export interface Service extends Client {
+export interface Service extends TrellisAuthClient {
   readonly handle: ServiceHandle;
+  with<TDeps>(deps: TDeps): ServiceWithDeps<TDeps>;
+}
+
+export type ServiceWithDeps<TDeps> = Omit<TrellisAuthClient, "event"> & {
+  readonly event: ServiceEventSurface<TDeps>;
+  readonly handle: ServiceHandle<TDeps>;
+  with<TNextDeps>(deps: TNextDeps): ServiceWithDeps<TNextDeps>;
+};
+
+export interface ServiceEventSurface<TDeps> {
+  readonly auth: {
+    connectionsClosed: { publish(event: Omit<Types.AuthConnectionsClosedEvent, "header">): AsyncResult<void, ValidationError | UnexpectedError>; prepare(event: Omit<Types.AuthConnectionsClosedEvent, "header">): Result<PreparedTrellisEvent<Omit<Types.AuthConnectionsClosedEvent, "header">>, ValidationError | UnexpectedError>; listen(handler: ServiceEventHandler<Types.AuthConnectionsClosedEvent, TDeps>, subjectData?: Record<string, unknown>, opts?: EventOpts): AsyncResult<void, ValidationError | UnexpectedError>; };
+    connectionsKicked: { publish(event: Omit<Types.AuthConnectionsKickedEvent, "header">): AsyncResult<void, ValidationError | UnexpectedError>; prepare(event: Omit<Types.AuthConnectionsKickedEvent, "header">): Result<PreparedTrellisEvent<Omit<Types.AuthConnectionsKickedEvent, "header">>, ValidationError | UnexpectedError>; listen(handler: ServiceEventHandler<Types.AuthConnectionsKickedEvent, TDeps>, subjectData?: Record<string, unknown>, opts?: EventOpts): AsyncResult<void, ValidationError | UnexpectedError>; };
+    connectionsOpened: { publish(event: Omit<Types.AuthConnectionsOpenedEvent, "header">): AsyncResult<void, ValidationError | UnexpectedError>; prepare(event: Omit<Types.AuthConnectionsOpenedEvent, "header">): Result<PreparedTrellisEvent<Omit<Types.AuthConnectionsOpenedEvent, "header">>, ValidationError | UnexpectedError>; listen(handler: ServiceEventHandler<Types.AuthConnectionsOpenedEvent, TDeps>, subjectData?: Record<string, unknown>, opts?: EventOpts): AsyncResult<void, ValidationError | UnexpectedError>; };
+    deviceUserAuthoritiesApproved: { publish(event: Omit<Types.AuthDeviceUserAuthoritiesApprovedEvent, "header">): AsyncResult<void, ValidationError | UnexpectedError>; prepare(event: Omit<Types.AuthDeviceUserAuthoritiesApprovedEvent, "header">): Result<PreparedTrellisEvent<Omit<Types.AuthDeviceUserAuthoritiesApprovedEvent, "header">>, ValidationError | UnexpectedError>; listen(handler: ServiceEventHandler<Types.AuthDeviceUserAuthoritiesApprovedEvent, TDeps>, subjectData?: Record<string, unknown>, opts?: EventOpts): AsyncResult<void, ValidationError | UnexpectedError>; };
+    deviceUserAuthoritiesRequested: { publish(event: Omit<Types.AuthDeviceUserAuthoritiesRequestedEvent, "header">): AsyncResult<void, ValidationError | UnexpectedError>; prepare(event: Omit<Types.AuthDeviceUserAuthoritiesRequestedEvent, "header">): Result<PreparedTrellisEvent<Omit<Types.AuthDeviceUserAuthoritiesRequestedEvent, "header">>, ValidationError | UnexpectedError>; listen(handler: ServiceEventHandler<Types.AuthDeviceUserAuthoritiesRequestedEvent, TDeps>, subjectData?: Record<string, unknown>, opts?: EventOpts): AsyncResult<void, ValidationError | UnexpectedError>; };
+    deviceUserAuthoritiesResolved: { publish(event: Omit<Types.AuthDeviceUserAuthoritiesResolvedEvent, "header">): AsyncResult<void, ValidationError | UnexpectedError>; prepare(event: Omit<Types.AuthDeviceUserAuthoritiesResolvedEvent, "header">): Result<PreparedTrellisEvent<Omit<Types.AuthDeviceUserAuthoritiesResolvedEvent, "header">>, ValidationError | UnexpectedError>; listen(handler: ServiceEventHandler<Types.AuthDeviceUserAuthoritiesResolvedEvent, TDeps>, subjectData?: Record<string, unknown>, opts?: EventOpts): AsyncResult<void, ValidationError | UnexpectedError>; };
+    deviceUserAuthoritiesReviewRequested: { publish(event: Omit<Types.AuthDeviceUserAuthoritiesReviewRequestedEvent, "header">): AsyncResult<void, ValidationError | UnexpectedError>; prepare(event: Omit<Types.AuthDeviceUserAuthoritiesReviewRequestedEvent, "header">): Result<PreparedTrellisEvent<Omit<Types.AuthDeviceUserAuthoritiesReviewRequestedEvent, "header">>, ValidationError | UnexpectedError>; listen(handler: ServiceEventHandler<Types.AuthDeviceUserAuthoritiesReviewRequestedEvent, TDeps>, subjectData?: Record<string, unknown>, opts?: EventOpts): AsyncResult<void, ValidationError | UnexpectedError>; };
+    sessionsRevoked: { publish(event: Omit<Types.AuthSessionsRevokedEvent, "header">): AsyncResult<void, ValidationError | UnexpectedError>; prepare(event: Omit<Types.AuthSessionsRevokedEvent, "header">): Result<PreparedTrellisEvent<Omit<Types.AuthSessionsRevokedEvent, "header">>, ValidationError | UnexpectedError>; listen(handler: ServiceEventHandler<Types.AuthSessionsRevokedEvent, TDeps>, subjectData?: Record<string, unknown>, opts?: EventOpts): AsyncResult<void, ValidationError | UnexpectedError>; };
+  };
 }
 
-export interface ServiceHandle {
+export interface ServiceHandle<TDeps = undefined> {
   readonly rpc: {
     readonly auth: {
-      capabilitiesList(handler: RpcHandler<Types.AuthCapabilitiesListInput, Types.AuthCapabilitiesListOutput>): Promise<void>;
-      capabilityGroupsDelete(handler: RpcHandler<Types.AuthCapabilityGroupsDeleteInput, Types.AuthCapabilityGroupsDeleteOutput>): Promise<void>;
-      capabilityGroupsGet(handler: RpcHandler<Types.AuthCapabilityGroupsGetInput, Types.AuthCapabilityGroupsGetOutput>): Promise<void>;
-      capabilityGroupsList(handler: RpcHandler<Types.AuthCapabilityGroupsListInput, Types.AuthCapabilityGroupsListOutput>): Promise<void>;
-      capabilityGroupsPut(handler: RpcHandler<Types.AuthCapabilityGroupsPutInput, Types.AuthCapabilityGroupsPutOutput>): Promise<void>;
-      catalogIssuesResolve(handler: RpcHandler<Types.AuthCatalogIssuesResolveInput, Types.AuthCatalogIssuesResolveOutput>): Promise<void>;
-      connectionsKick(handler: RpcHandler<Types.AuthConnectionsKickInput, Types.AuthConnectionsKickOutput>): Promise<void>;
-      connectionsList(handler: RpcHandler<Types.AuthConnectionsListInput, Types.AuthConnectionsListOutput>): Promise<void>;
-      deploymentAuthorityAcceptMigration(handler: RpcHandler<Types.AuthDeploymentAuthorityAcceptMigrationInput, Types.AuthDeploymentAuthorityAcceptMigrationOutput>): Promise<void>;
-      deploymentAuthorityAcceptUpdate(handler: RpcHandler<Types.AuthDeploymentAuthorityAcceptUpdateInput, Types.AuthDeploymentAuthorityAcceptUpdateOutput>): Promise<void>;
-      deploymentAuthorityGet(handler: RpcHandler<Types.AuthDeploymentAuthorityGetInput, Types.AuthDeploymentAuthorityGetOutput>): Promise<void>;
-      deploymentAuthorityGrantOverridesList(handler: RpcHandler<Types.AuthDeploymentAuthorityGrantOverridesListInput, Types.AuthDeploymentAuthorityGrantOverridesListOutput>): Promise<void>;
-      deploymentAuthorityGrantOverridesPut(handler: RpcHandler<Types.AuthDeploymentAuthorityGrantOverridesPutInput, Types.AuthDeploymentAuthorityGrantOverridesPutOutput>): Promise<void>;
-      deploymentAuthorityGrantOverridesRemove(handler: RpcHandler<Types.AuthDeploymentAuthorityGrantOverridesRemoveInput, Types.AuthDeploymentAuthorityGrantOverridesRemoveOutput>): Promise<void>;
-      deploymentAuthorityList(handler: RpcHandler<Types.AuthDeploymentAuthorityListInput, Types.AuthDeploymentAuthorityListOutput>): Promise<void>;
-      deploymentAuthorityPlan(handler: RpcHandler<Types.AuthDeploymentAuthorityPlanInput, Types.AuthDeploymentAuthorityPlanOutput>): Promise<void>;
-      deploymentAuthorityPlansGet(handler: RpcHandler<Types.AuthDeploymentAuthorityPlansGetInput, Types.AuthDeploymentAuthorityPlansGetOutput>): Promise<void>;
-      deploymentAuthorityPlansList(handler: RpcHandler<Types.AuthDeploymentAuthorityPlansListInput, Types.AuthDeploymentAuthorityPlansListOutput>): Promise<void>;
-      deploymentAuthorityReconcile(handler: RpcHandler<Types.AuthDeploymentAuthorityReconcileInput, Types.AuthDeploymentAuthorityReconcileOutput>): Promise<void>;
-      deploymentAuthorityReject(handler: RpcHandler<Types.AuthDeploymentAuthorityRejectInput, Types.AuthDeploymentAuthorityRejectOutput>): Promise<void>;
-      deploymentsCreate(handler: RpcHandler<Types.AuthDeploymentsCreateInput, Types.AuthDeploymentsCreateOutput>): Promise<void>;
-      deploymentsDisable(handler: RpcHandler<Types.AuthDeploymentsDisableInput, Types.AuthDeploymentsDisableOutput>): Promise<void>;
-      deploymentsEnable(handler: RpcHandler<Types.AuthDeploymentsEnableInput, Types.AuthDeploymentsEnableOutput>): Promise<void>;
-      deploymentsList(handler: RpcHandler<Types.AuthDeploymentsListInput, Types.AuthDeploymentsListOutput>): Promise<void>;
-      deploymentsRemove(handler: RpcHandler<Types.AuthDeploymentsRemoveInput, Types.AuthDeploymentsRemoveOutput>): Promise<void>;
-      deviceUserAuthoritiesList(handler: RpcHandler<Types.AuthDeviceUserAuthoritiesListInput, Types.AuthDeviceUserAuthoritiesListOutput>): Promise<void>;
-      deviceUserAuthoritiesReviewsDecide(handler: RpcHandler<Types.AuthDeviceUserAuthoritiesReviewsDecideInput, Types.AuthDeviceUserAuthoritiesReviewsDecideOutput>): Promise<void>;
-      deviceUserAuthoritiesReviewsList(handler: RpcHandler<Types.AuthDeviceUserAuthoritiesReviewsListInput, Types.AuthDeviceUserAuthoritiesReviewsListOutput>): Promise<void>;
-      deviceUserAuthoritiesRevoke(handler: RpcHandler<Types.AuthDeviceUserAuthoritiesRevokeInput, Types.AuthDeviceUserAuthoritiesRevokeOutput>): Promise<void>;
-      devicesConnectInfoGet(handler: RpcHandler<Types.AuthDevicesConnectInfoGetInput, Types.AuthDevicesConnectInfoGetOutput>): Promise<void>;
-      devicesDisable(handler: RpcHandler<Types.AuthDevicesDisableInput, Types.AuthDevicesDisableOutput>): Promise<void>;
-      devicesEnable(handler: RpcHandler<Types.AuthDevicesEnableInput, Types.AuthDevicesEnableOutput>): Promise<void>;
-      devicesList(handler: RpcHandler<Types.AuthDevicesListInput, Types.AuthDevicesListOutput>): Promise<void>;
-      devicesProvision(handler: RpcHandler<Types.AuthDevicesProvisionInput, Types.AuthDevicesProvisionOutput>): Promise<void>;
-      devicesRemove(handler: RpcHandler<Types.AuthDevicesRemoveInput, Types.AuthDevicesRemoveOutput>): Promise<void>;
-      health(handler: RpcHandler<Types.AuthHealthInput, Types.AuthHealthOutput>): Promise<void>;
-      identitiesList(handler: RpcHandler<Types.AuthIdentitiesListInput, Types.AuthIdentitiesListOutput>): Promise<void>;
-      identityGrantsList(handler: RpcHandler<Types.AuthIdentityGrantsListInput, Types.AuthIdentityGrantsListOutput>): Promise<void>;
-      identityGrantsRevoke(handler: RpcHandler<Types.AuthIdentityGrantsRevokeInput, Types.AuthIdentityGrantsRevokeOutput>): Promise<void>;
-      portalsGet(handler: RpcHandler<Types.AuthPortalsGetInput, Types.AuthPortalsGetOutput>): Promise<void>;
-      portalsList(handler: RpcHandler<Types.AuthPortalsListInput, Types.AuthPortalsListOutput>): Promise<void>;
-      portalsLoginSettingsGet(handler: RpcHandler<Types.AuthPortalsLoginSettingsGetInput, Types.AuthPortalsLoginSettingsGetOutput>): Promise<void>;
-      portalsLoginSettingsUpdate(handler: RpcHandler<Types.AuthPortalsLoginSettingsUpdateInput, Types.AuthPortalsLoginSettingsUpdateOutput>): Promise<void>;
-      portalsPut(handler: RpcHandler<Types.AuthPortalsPutInput, Types.AuthPortalsPutOutput>): Promise<void>;
-      portalsRemove(handler: RpcHandler<Types.AuthPortalsRemoveInput, Types.AuthPortalsRemoveOutput>): Promise<void>;
-      portalsRoutesPut(handler: RpcHandler<Types.AuthPortalsRoutesPutInput, Types.AuthPortalsRoutesPutOutput>): Promise<void>;
-      portalsRoutesRemove(handler: RpcHandler<Types.AuthPortalsRoutesRemoveInput, Types.AuthPortalsRoutesRemoveOutput>): Promise<void>;
-      requestsValidate(handler: RpcHandler<Types.AuthRequestsValidateInput, Types.AuthRequestsValidateOutput>): Promise<void>;
-      serviceInstancesDisable(handler: RpcHandler<Types.AuthServiceInstancesDisableInput, Types.AuthServiceInstancesDisableOutput>): Promise<void>;
-      serviceInstancesEnable(handler: RpcHandler<Types.AuthServiceInstancesEnableInput, Types.AuthServiceInstancesEnableOutput>): Promise<void>;
-      serviceInstancesList(handler: RpcHandler<Types.AuthServiceInstancesListInput, Types.AuthServiceInstancesListOutput>): Promise<void>;
-      serviceInstancesProvision(handler: RpcHandler<Types.AuthServiceInstancesProvisionInput, Types.AuthServiceInstancesProvisionOutput>): Promise<void>;
-      serviceInstancesRemove(handler: RpcHandler<Types.AuthServiceInstancesRemoveInput, Types.AuthServiceInstancesRemoveOutput>): Promise<void>;
-      sessionsList(handler: RpcHandler<Types.AuthSessionsListInput, Types.AuthSessionsListOutput>): Promise<void>;
-      sessionsLogout(handler: RpcHandler<Types.AuthSessionsLogoutInput, Types.AuthSessionsLogoutOutput>): Promise<void>;
-      sessionsMe(handler: RpcHandler<Types.AuthSessionsMeInput, Types.AuthSessionsMeOutput>): Promise<void>;
-      sessionsRevoke(handler: RpcHandler<Types.AuthSessionsRevokeInput, Types.AuthSessionsRevokeOutput>): Promise<void>;
-      userIdentitiesList(handler: RpcHandler<Types.AuthUserIdentitiesListInput, Types.AuthUserIdentitiesListOutput>): Promise<void>;
-      userIdentitiesUnlink(handler: RpcHandler<Types.AuthUserIdentitiesUnlinkInput, Types.AuthUserIdentitiesUnlinkOutput>): Promise<void>;
-      usersCreate(handler: RpcHandler<Types.AuthUsersCreateInput, Types.AuthUsersCreateOutput>): Promise<void>;
-      usersGet(handler: RpcHandler<Types.AuthUsersGetInput, Types.AuthUsersGetOutput>): Promise<void>;
-      usersIdentityLinkCreate(handler: RpcHandler<Types.AuthUsersIdentityLinkCreateInput, Types.AuthUsersIdentityLinkCreateOutput>): Promise<void>;
-      usersList(handler: RpcHandler<Types.AuthUsersListInput, Types.AuthUsersListOutput>): Promise<void>;
-      usersPasswordChange(handler: RpcHandler<Types.AuthUsersPasswordChangeInput, Types.AuthUsersPasswordChangeOutput>): Promise<void>;
-      usersPasswordResetCreate(handler: RpcHandler<Types.AuthUsersPasswordResetCreateInput, Types.AuthUsersPasswordResetCreateOutput>): Promise<void>;
-      usersUpdate(handler: RpcHandler<Types.AuthUsersUpdateInput, Types.AuthUsersUpdateOutput>): Promise<void>;
+      capabilitiesList(handler: RpcHandler<Types.AuthCapabilitiesListInput, Types.AuthCapabilitiesListOutput, TDeps>): Promise<void>;
+      capabilityGroupsDelete(handler: RpcHandler<Types.AuthCapabilityGroupsDeleteInput, Types.AuthCapabilityGroupsDeleteOutput, TDeps>): Promise<void>;
+      capabilityGroupsGet(handler: RpcHandler<Types.AuthCapabilityGroupsGetInput, Types.AuthCapabilityGroupsGetOutput, TDeps>): Promise<void>;
+      capabilityGroupsList(handler: RpcHandler<Types.AuthCapabilityGroupsListInput, Types.AuthCapabilityGroupsListOutput, TDeps>): Promise<void>;
+      capabilityGroupsPut(handler: RpcHandler<Types.AuthCapabilityGroupsPutInput, Types.AuthCapabilityGroupsPutOutput, TDeps>): Promise<void>;
+      catalogIssuesResolve(handler: RpcHandler<Types.AuthCatalogIssuesResolveInput, Types.AuthCatalogIssuesResolveOutput, TDeps>): Promise<void>;
+      connectionsKick(handler: RpcHandler<Types.AuthConnectionsKickInput, Types.AuthConnectionsKickOutput, TDeps>): Promise<void>;
+      connectionsList(handler: RpcHandler<Types.AuthConnectionsListInput, Types.AuthConnectionsListOutput, TDeps>): Promise<void>;
+      deploymentAuthorityAcceptMigration(handler: RpcHandler<Types.AuthDeploymentAuthorityAcceptMigrationInput, Types.AuthDeploymentAuthorityAcceptMigrationOutput, TDeps>): Promise<void>;
+      deploymentAuthorityAcceptUpdate(handler: RpcHandler<Types.AuthDeploymentAuthorityAcceptUpdateInput, Types.AuthDeploymentAuthorityAcceptUpdateOutput, TDeps>): Promise<void>;
+      deploymentAuthorityGet(handler: RpcHandler<Types.AuthDeploymentAuthorityGetInput, Types.AuthDeploymentAuthorityGetOutput, TDeps>): Promise<void>;
+      deploymentAuthorityGrantOverridesList(handler: RpcHandler<Types.AuthDeploymentAuthorityGrantOverridesListInput, Types.AuthDeploymentAuthorityGrantOverridesListOutput, TDeps>): Promise<void>;
+      deploymentAuthorityGrantOverridesPut(handler: RpcHandler<Types.AuthDeploymentAuthorityGrantOverridesPutInput, Types.AuthDeploymentAuthorityGrantOverridesPutOutput, TDeps>): Promise<void>;
+      deploymentAuthorityGrantOverridesRemove(handler: RpcHandler<Types.AuthDeploymentAuthorityGrantOverridesRemoveInput, Types.AuthDeploymentAuthorityGrantOverridesRemoveOutput, TDeps>): Promise<void>;
+      deploymentAuthorityList(handler: RpcHandler<Types.AuthDeploymentAuthorityListInput, Types.AuthDeploymentAuthorityListOutput, TDeps>): Promise<void>;
+      deploymentAuthorityPlan(handler: RpcHandler<Types.AuthDeploymentAuthorityPlanInput, Types.AuthDeploymentAuthorityPlanOutput, TDeps>): Promise<void>;
+      deploymentAuthorityPlansGet(handler: RpcHandler<Types.AuthDeploymentAuthorityPlansGetInput, Types.AuthDeploymentAuthorityPlansGetOutput, TDeps>): Promise<void>;
+      deploymentAuthorityPlansList(handler: RpcHandler<Types.AuthDeploymentAuthorityPlansListInput, Types.AuthDeploymentAuthorityPlansListOutput, TDeps>): Promise<void>;
+      deploymentAuthorityReconcile(handler: RpcHandler<Types.AuthDeploymentAuthorityReconcileInput, Types.AuthDeploymentAuthorityReconcileOutput, TDeps>): Promise<void>;
+      deploymentAuthorityReject(handler: RpcHandler<Types.AuthDeploymentAuthorityRejectInput, Types.AuthDeploymentAuthorityRejectOutput, TDeps>): Promise<void>;
+      deploymentsCreate(handler: RpcHandler<Types.AuthDeploymentsCreateInput, Types.AuthDeploymentsCreateOutput, TDeps>): Promise<void>;
+      deploymentsDisable(handler: RpcHandler<Types.AuthDeploymentsDisableInput, Types.AuthDeploymentsDisableOutput, TDeps>): Promise<void>;
+      deploymentsEnable(handler: RpcHandler<Types.AuthDeploymentsEnableInput, Types.AuthDeploymentsEnableOutput, TDeps>): Promise<void>;
+      deploymentsList(handler: RpcHandler<Types.AuthDeploymentsListInput, Types.AuthDeploymentsListOutput, TDeps>): Promise<void>;
+      deploymentsRemove(handler: RpcHandler<Types.AuthDeploymentsRemoveInput, Types.AuthDeploymentsRemoveOutput, TDeps>): Promise<void>;
+      deviceUserAuthoritiesList(handler: RpcHandler<Types.AuthDeviceUserAuthoritiesListInput, Types.AuthDeviceUserAuthoritiesListOutput, TDeps>): Promise<void>;
+      deviceUserAuthoritiesReviewsDecide(handler: RpcHandler<Types.AuthDeviceUserAuthoritiesReviewsDecideInput, Types.AuthDeviceUserAuthoritiesReviewsDecideOutput, TDeps>): Promise<void>;
+      deviceUserAuthoritiesReviewsList(handler: RpcHandler<Types.AuthDeviceUserAuthoritiesReviewsListInput, Types.AuthDeviceUserAuthoritiesReviewsListOutput, TDeps>): Promise<void>;
+      deviceUserAuthoritiesRevoke(handler: RpcHandler<Types.AuthDeviceUserAuthoritiesRevokeInput, Types.AuthDeviceUserAuthoritiesRevokeOutput, TDeps>): Promise<void>;
+      devicesConnectInfoGet(handler: RpcHandler<Types.AuthDevicesConnectInfoGetInput, Types.AuthDevicesConnectInfoGetOutput, TDeps>): Promise<void>;
+      devicesDisable(handler: RpcHandler<Types.AuthDevicesDisableInput, Types.AuthDevicesDisableOutput, TDeps>): Promise<void>;
+      devicesEnable(handler: RpcHandler<Types.AuthDevicesEnableInput, Types.AuthDevicesEnableOutput, TDeps>): Promise<void>;
+      devicesList(handler: RpcHandler<Types.AuthDevicesListInput, Types.AuthDevicesListOutput, TDeps>): Promise<void>;
+      devicesProvision(handler: RpcHandler<Types.AuthDevicesProvisionInput, Types.AuthDevicesProvisionOutput, TDeps>): Promise<void>;
+      devicesRemove(handler: RpcHandler<Types.AuthDevicesRemoveInput, Types.AuthDevicesRemoveOutput, TDeps>): Promise<void>;
+      health(handler: RpcHandler<Types.AuthHealthInput, Types.AuthHealthOutput, TDeps>): Promise<void>;
+      identitiesList(handler: RpcHandler<Types.AuthIdentitiesListInput, Types.AuthIdentitiesListOutput, TDeps>): Promise<void>;
+      identityGrantsList(handler: RpcHandler<Types.AuthIdentityGrantsListInput, Types.AuthIdentityGrantsListOutput, TDeps>): Promise<void>;
+      identityGrantsRevoke(handler: RpcHandler<Types.AuthIdentityGrantsRevokeInput, Types.AuthIdentityGrantsRevokeOutput, TDeps>): Promise<void>;
+      portalsGet(handler: RpcHandler<Types.AuthPortalsGetInput, Types.AuthPortalsGetOutput, TDeps>): Promise<void>;
+      portalsList(handler: RpcHandler<Types.AuthPortalsListInput, Types.AuthPortalsListOutput, TDeps>): Promise<void>;
+      portalsLoginSettingsGet(handler: RpcHandler<Types.AuthPortalsLoginSettingsGetInput, Types.AuthPortalsLoginSettingsGetOutput, TDeps>): Promise<void>;
+      portalsLoginSettingsUpdate(handler: RpcHandler<Types.AuthPortalsLoginSettingsUpdateInput, Types.AuthPortalsLoginSettingsUpdateOutput, TDeps>): Promise<void>;
+      portalsPut(handler: RpcHandler<Types.AuthPortalsPutInput, Types.AuthPortalsPutOutput, TDeps>): Promise<void>;
+      portalsRemove(handler: RpcHandler<Types.AuthPortalsRemoveInput, Types.AuthPortalsRemoveOutput, TDeps>): Promise<void>;
+      portalsRoutesPut(handler: RpcHandler<Types.AuthPortalsRoutesPutInput, Types.AuthPortalsRoutesPutOutput, TDeps>): Promise<void>;
+      portalsRoutesRemove(handler: RpcHandler<Types.AuthPortalsRoutesRemoveInput, Types.AuthPortalsRoutesRemoveOutput, TDeps>): Promise<void>;
+      requestsValidate(handler: RpcHandler<Types.AuthRequestsValidateInput, Types.AuthRequestsValidateOutput, TDeps>): Promise<void>;
+      serviceInstancesDisable(handler: RpcHandler<Types.AuthServiceInstancesDisableInput, Types.AuthServiceInstancesDisableOutput, TDeps>): Promise<void>;
+      serviceInstancesEnable(handler: RpcHandler<Types.AuthServiceInstancesEnableInput, Types.AuthServiceInstancesEnableOutput, TDeps>): Promise<void>;
+      serviceInstancesList(handler: RpcHandler<Types.AuthServiceInstancesListInput, Types.AuthServiceInstancesListOutput, TDeps>): Promise<void>;
+      serviceInstancesProvision(handler: RpcHandler<Types.AuthServiceInstancesProvisionInput, Types.AuthServiceInstancesProvisionOutput, TDeps>): Promise<void>;
+      serviceInstancesRemove(handler: RpcHandler<Types.AuthServiceInstancesRemoveInput, Types.AuthServiceInstancesRemoveOutput, TDeps>): Promise<void>;
+      sessionsList(handler: RpcHandler<Types.AuthSessionsListInput, Types.AuthSessionsListOutput, TDeps>): Promise<void>;
+      sessionsLogout(handler: RpcHandler<Types.AuthSessionsLogoutInput, Types.AuthSessionsLogoutOutput, TDeps>): Promise<void>;
+      sessionsMe(handler: RpcHandler<Types.AuthSessionsMeInput, Types.AuthSessionsMeOutput, TDeps>): Promise<void>;
+      sessionsRevoke(handler: RpcHandler<Types.AuthSessionsRevokeInput, Types.AuthSessionsRevokeOutput, TDeps>): Promise<void>;
+      userIdentitiesList(handler: RpcHandler<Types.AuthUserIdentitiesListInput, Types.AuthUserIdentitiesListOutput, TDeps>): Promise<void>;
+      userIdentitiesUnlink(handler: RpcHandler<Types.AuthUserIdentitiesUnlinkInput, Types.AuthUserIdentitiesUnlinkOutput, TDeps>): Promise<void>;
+      usersCreate(handler: RpcHandler<Types.AuthUsersCreateInput, Types.AuthUsersCreateOutput, TDeps>): Promise<void>;
+      usersGet(handler: RpcHandler<Types.AuthUsersGetInput, Types.AuthUsersGetOutput, TDeps>): Promise<void>;
+      usersIdentityLinkCreate(handler: RpcHandler<Types.AuthUsersIdentityLinkCreateInput, Types.AuthUsersIdentityLinkCreateOutput, TDeps>): Promise<void>;
+      usersList(handler: RpcHandler<Types.AuthUsersListInput, Types.AuthUsersListOutput, TDeps>): Promise<void>;
+      usersPasswordChange(handler: RpcHandler<Types.AuthUsersPasswordChangeInput, Types.AuthUsersPasswordChangeOutput, TDeps>): Promise<void>;
+      usersPasswordResetCreate(handler: RpcHandler<Types.AuthUsersPasswordResetCreateInput, Types.AuthUsersPasswordResetCreateOutput, TDeps>): Promise<void>;
+      usersUpdate(handler: RpcHandler<Types.AuthUsersUpdateInput, Types.AuthUsersUpdateOutput, TDeps>): Promise<void>;
     };
   };
   readonly feed: {};
   readonly operation: {
     readonly auth: {
-      deviceUserAuthoritiesResolve: ((handler: (context: { input: Types.AuthDeviceUserAuthoritiesResolveInput; client: HandlerClient }) => unknown | Promise<unknown>) => Promise<void>) & { accept(args: { sessionKey: string }): AsyncResult<AcceptedOperation<Types.AuthDeviceUserAuthoritiesResolveProgress, Types.AuthDeviceUserAuthoritiesResolveOutput>, UnexpectedError>; control(operationId: string): AsyncResult<OperationRuntimeHandle<Types.AuthDeviceUserAuthoritiesResolveProgress, Types.AuthDeviceUserAuthoritiesResolveOutput>, BaseError>; };
+      deviceUserAuthoritiesResolve: ((handler: OperationHandler<Types.AuthDeviceUserAuthoritiesResolveInput, Types.AuthDeviceUserAuthoritiesResolveProgress, Types.AuthDeviceUserAuthoritiesResolveOutput, {}, TDeps>) => Promise<void>) & { accept(args: { sessionKey: string }): AsyncResult<AcceptedOperation<Types.AuthDeviceUserAuthoritiesResolveProgress, Types.AuthDeviceUserAuthoritiesResolveOutput>, UnexpectedError>; control(operationId: string): AsyncResult<OperationRuntimeHandle<Types.AuthDeviceUserAuthoritiesResolveProgress, Types.AuthDeviceUserAuthoritiesResolveOutput>, BaseError>; };
     };
   };
 }

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

@@ -2,6 +2,6 @@ export { API, OWNED_API } from "./api.js";
 export type { Api, ApiViews, OwnedApi } from "./api.js";
 export * from "./types.js";
 export * from "./schemas.js";
-export type { Client, HandlerClient, TrellisAuthClient, TrellisAuthState } from "./client.js";
+export type { Client, HandlerClient, Service, ServiceEventSurface, ServiceHandle, ServiceWithDeps, TrellisAuthClient, TrellisAuthState } from "./client.js";
 export type { AuthDeviceUserAuthoritiesResolveOperation, AuthDeviceUserAuthoritiesResolveOperationRef, AuthDeviceUserAuthoritiesResolveTerminal } from "./client.js";
 export { CONTRACT, CONTRACT_DIGEST, CONTRACT_ID, use, sdk } from "./contract.js";

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

@@ -1,13 +1,21 @@
 // Generated from ./generated/contracts/manifests/trellis.core@v1.json
-import type { AcceptedOperation, AsyncResult, BaseError, EventOpts, FeedSubscribeOpts, FeedSubscription, HandlerTrellis, MapStateStoreClient, MaybeAsync, OperationInputBuilder, OperationObserverCallbacks, OperationRef, OperationRefData, OperationRuntimeHandle, PreparedTrellisEvent, ReceiveTransferGrant, ReceiveTransferHandle, RequestOpts, Result, RpcHandlerContext, SendTransferGrant, SendTransferHandle, TerminalOperation, TransferCapableOperationInputBuilder, TrellisConnection, UnexpectedError, ValidationError, ValueStateStoreClient } from "../../../index.js";
+import type { AcceptedOperation, AsyncResult, BaseError, EventListenerContext, EventOpts, FeedSubscribeOpts, FeedSubscription, HandlerTrellis, MapStateStoreClient, MaybeAsync, OperationInputBuilder, OperationObserverCallbacks, OperationRef, OperationRefData, OperationRuntimeHandle, OperationTransferHandle, PreparedTrellisEvent, ReceiveTransferGrant, ReceiveTransferHandle, RequestOpts, Result, RpcHandlerContext, SendTransferGrant, SendTransferHandle, TerminalOperation, TransferCapableOperationInputBuilder, TrellisConnection, UnexpectedError, ValidationError, ValueStateStoreClient } from "../../../index.js";
 import type { API, Api } from "./api.js";
 import type * as Types from "./types.js";
 
+type WithDeps<TDeps> = [TDeps] extends [undefined] ? {} : { deps: TDeps };
+
 type EventCallback<TMessage> = {
-  bivarianceHack(message: TMessage): MaybeAsync<void, BaseError>;
+  bivarianceHack(message: TMessage, context: EventListenerContext): MaybeAsync<void, BaseError>;
 }["bivarianceHack"];
 
-type RpcHandler<TInput, TOutput> = (args: { input: TInput; context: RpcHandlerContext; client: HandlerClient }) => MaybeAsync<TOutput, BaseError>;
+type ServiceEventHandler<TEvent, TDeps = undefined> = (args: { event: TEvent; context: EventListenerContext; client: HandlerClient } & WithDeps<TDeps>) => MaybeAsync<void, BaseError>;
+
+type RpcHandler<TInput, TOutput, TDeps = undefined> = (args: { input: TInput; context: RpcHandlerContext; client: HandlerClient } & WithDeps<TDeps>) => MaybeAsync<TOutput, BaseError>;
+
+type FeedHandler<TInput, TEvent, TDeps = undefined> = (context: { input: TInput; caller: unknown; signal: AbortSignal; emit(event: TEvent): AsyncResult<void, ValidationError | UnexpectedError>; client: HandlerClient } & WithDeps<TDeps>) => unknown | Promise<unknown>;
+
+type OperationHandler<TInput, TProgress, TOutput, TTransfer, TDeps = undefined> = (context: { input: TInput; op: OperationRuntimeHandle<TProgress, TOutput>; caller: unknown; client: HandlerClient } & TTransfer & WithDeps<TDeps>) => unknown | Promise<unknown>;
 
 export type TrellisCoreState = {};
 
@@ -33,16 +41,25 @@ export interface TrellisCoreClient {
   wait(): AsyncResult<void, BaseError>;
 }
 
-export interface Service extends Client {
+export interface Service extends TrellisCoreClient {
   readonly handle: ServiceHandle;
+  with<TDeps>(deps: TDeps): ServiceWithDeps<TDeps>;
 }
 
-export interface ServiceHandle {
+export type ServiceWithDeps<TDeps> = Omit<TrellisCoreClient, "event"> & {
+  readonly event: ServiceEventSurface<TDeps>;
+  readonly handle: ServiceHandle<TDeps>;
+  with<TNextDeps>(deps: TNextDeps): ServiceWithDeps<TNextDeps>;
+};
+
+export type ServiceEventSurface<TDeps> = {};
+
+export interface ServiceHandle<TDeps = undefined> {
   readonly rpc: {
     readonly trellis: {
-      catalog(handler: RpcHandler<Types.TrellisCatalogInput, Types.TrellisCatalogOutput>): Promise<void>;
-      contractGet(handler: RpcHandler<Types.TrellisContractGetInput, Types.TrellisContractGetOutput>): Promise<void>;
-      surfaceStatus(handler: RpcHandler<Types.TrellisSurfaceStatusInput, Types.TrellisSurfaceStatusOutput>): Promise<void>;
+      catalog(handler: RpcHandler<Types.TrellisCatalogInput, Types.TrellisCatalogOutput, TDeps>): Promise<void>;
+      contractGet(handler: RpcHandler<Types.TrellisContractGetInput, Types.TrellisContractGetOutput, TDeps>): Promise<void>;
+      surfaceStatus(handler: RpcHandler<Types.TrellisSurfaceStatusInput, Types.TrellisSurfaceStatusOutput, TDeps>): Promise<void>;
     };
   };
   readonly feed: {};

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

@@ -2,5 +2,5 @@ export { API, OWNED_API } from "./api.js";
 export type { Api, ApiViews, OwnedApi } from "./api.js";
 export * from "./types.js";
 export * from "./schemas.js";
-export type { Client, HandlerClient, TrellisCoreClient, TrellisCoreState } from "./client.js";
+export type { Client, HandlerClient, Service, ServiceEventSurface, ServiceHandle, ServiceWithDeps, TrellisCoreClient, TrellisCoreState } from "./client.js";
 export { CONTRACT, CONTRACT_DIGEST, CONTRACT_ID, use, sdk } from "./contract.js";

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

@@ -1,13 +1,21 @@
 // Generated from ./generated/contracts/manifests/trellis.health@v1.json
-import type { AcceptedOperation, AsyncResult, BaseError, EventOpts, FeedSubscribeOpts, FeedSubscription, HandlerTrellis, MapStateStoreClient, MaybeAsync, OperationInputBuilder, OperationObserverCallbacks, OperationRef, OperationRefData, OperationRuntimeHandle, PreparedTrellisEvent, ReceiveTransferGrant, ReceiveTransferHandle, RequestOpts, Result, RpcHandlerContext, SendTransferGrant, SendTransferHandle, TerminalOperation, TransferCapableOperationInputBuilder, TrellisConnection, UnexpectedError, ValidationError, ValueStateStoreClient } from "../../../index.js";
+import type { AcceptedOperation, AsyncResult, BaseError, EventListenerContext, EventOpts, FeedSubscribeOpts, FeedSubscription, HandlerTrellis, MapStateStoreClient, MaybeAsync, OperationInputBuilder, OperationObserverCallbacks, OperationRef, OperationRefData, OperationRuntimeHandle, OperationTransferHandle, PreparedTrellisEvent, ReceiveTransferGrant, ReceiveTransferHandle, RequestOpts, Result, RpcHandlerContext, SendTransferGrant, SendTransferHandle, TerminalOperation, TransferCapableOperationInputBuilder, TrellisConnection, UnexpectedError, ValidationError, ValueStateStoreClient } from "../../../index.js";
 import type { API, Api } from "./api.js";
 import type * as Types from "./types.js";
 
+type WithDeps<TDeps> = [TDeps] extends [undefined] ? {} : { deps: TDeps };
+
 type EventCallback<TMessage> = {
-  bivarianceHack(message: TMessage): MaybeAsync<void, BaseError>;
+  bivarianceHack(message: TMessage, context: EventListenerContext): MaybeAsync<void, BaseError>;
 }["bivarianceHack"];
 
-type RpcHandler<TInput, TOutput> = (args: { input: TInput; context: RpcHandlerContext; client: HandlerClient }) => MaybeAsync<TOutput, BaseError>;
+type ServiceEventHandler<TEvent, TDeps = undefined> = (args: { event: TEvent; context: EventListenerContext; client: HandlerClient } & WithDeps<TDeps>) => MaybeAsync<void, BaseError>;
+
+type RpcHandler<TInput, TOutput, TDeps = undefined> = (args: { input: TInput; context: RpcHandlerContext; client: HandlerClient } & WithDeps<TDeps>) => MaybeAsync<TOutput, BaseError>;
+
+type FeedHandler<TInput, TEvent, TDeps = undefined> = (context: { input: TInput; caller: unknown; signal: AbortSignal; emit(event: TEvent): AsyncResult<void, ValidationError | UnexpectedError>; client: HandlerClient } & WithDeps<TDeps>) => unknown | Promise<unknown>;
+
+type OperationHandler<TInput, TProgress, TOutput, TTransfer, TDeps = undefined> = (context: { input: TInput; op: OperationRuntimeHandle<TProgress, TOutput>; caller: unknown; client: HandlerClient } & TTransfer & WithDeps<TDeps>) => unknown | Promise<unknown>;
 
 export type TrellisHealthState = {};
 
@@ -31,11 +39,24 @@ export interface TrellisHealthClient {
   wait(): AsyncResult<void, BaseError>;
 }
 
-export interface Service extends Client {
+export interface Service extends TrellisHealthClient {
   readonly handle: ServiceHandle;
+  with<TDeps>(deps: TDeps): ServiceWithDeps<TDeps>;
+}
+
+export type ServiceWithDeps<TDeps> = Omit<TrellisHealthClient, "event"> & {
+  readonly event: ServiceEventSurface<TDeps>;
+  readonly handle: ServiceHandle<TDeps>;
+  with<TNextDeps>(deps: TNextDeps): ServiceWithDeps<TNextDeps>;
+};
+
+export interface ServiceEventSurface<TDeps> {
+  readonly health: {
+    heartbeat: { publish(event: Omit<Types.HealthHeartbeatEvent, "header">): AsyncResult<void, ValidationError | UnexpectedError>; prepare(event: Omit<Types.HealthHeartbeatEvent, "header">): Result<PreparedTrellisEvent<Omit<Types.HealthHeartbeatEvent, "header">>, ValidationError | UnexpectedError>; listen(handler: ServiceEventHandler<Types.HealthHeartbeatEvent, TDeps>, subjectData?: Record<string, unknown>, opts?: EventOpts): AsyncResult<void, ValidationError | UnexpectedError>; };
+  };
 }
 
-export interface ServiceHandle {
+export interface ServiceHandle<TDeps = undefined> {
   readonly rpc: {};
   readonly feed: {};
   readonly operation: {};

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

@@ -2,5 +2,5 @@ export { API, OWNED_API } from "./api.js";
 export type { Api, ApiViews, OwnedApi } from "./api.js";
 export * from "./types.js";
 export * from "./schemas.js";
-export type { Client, HandlerClient, TrellisHealthClient, TrellisHealthState } from "./client.js";
+export type { Client, HandlerClient, Service, ServiceEventSurface, ServiceHandle, ServiceWithDeps, TrellisHealthClient, TrellisHealthState } from "./client.js";
 export { CONTRACT, CONTRACT_DIGEST, CONTRACT_ID, use, sdk } from "./contract.js";

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

@@ -1,16 +1,24 @@
 // Generated from ./generated/contracts/manifests/trellis.jobs@v1.json
-import type { AcceptedOperation, AsyncResult, BaseError, EventOpts, FeedSubscribeOpts, FeedSubscription, HandlerTrellis, MapStateStoreClient, MaybeAsync, OperationInputBuilder, OperationObserverCallbacks, OperationRef, OperationRefData, OperationRuntimeHandle, PreparedTrellisEvent, ReceiveTransferGrant, ReceiveTransferHandle, RequestOpts, Result, RpcHandlerContext, SendTransferGrant, SendTransferHandle, TerminalOperation, TransferCapableOperationInputBuilder, TrellisConnection, UnexpectedError, ValidationError, ValueStateStoreClient } from "../../../index.js";
+import type { AcceptedOperation, AsyncResult, BaseError, EventListenerContext, EventOpts, FeedSubscribeOpts, FeedSubscription, HandlerTrellis, MapStateStoreClient, MaybeAsync, OperationInputBuilder, OperationObserverCallbacks, OperationRef, OperationRefData, OperationRuntimeHandle, OperationTransferHandle, PreparedTrellisEvent, ReceiveTransferGrant, ReceiveTransferHandle, RequestOpts, Result, RpcHandlerContext, SendTransferGrant, SendTransferHandle, TerminalOperation, TransferCapableOperationInputBuilder, TrellisConnection, UnexpectedError, ValidationError, ValueStateStoreClient } from "../../../index.js";
 import type { API, Api } from "./api.js";
 import type * as Types from "./types.js";
 import type * as AuthSdk from "../auth/mod.js";
 import type * as CoreSdk from "../core/mod.js";
 import type * as HealthSdk from "../health/mod.js";
 
+type WithDeps<TDeps> = [TDeps] extends [undefined] ? {} : { deps: TDeps };
+
 type EventCallback<TMessage> = {
-  bivarianceHack(message: TMessage): MaybeAsync<void, BaseError>;
+  bivarianceHack(message: TMessage, context: EventListenerContext): MaybeAsync<void, BaseError>;
 }["bivarianceHack"];
 
-type RpcHandler<TInput, TOutput> = (args: { input: TInput; context: RpcHandlerContext; client: HandlerClient }) => MaybeAsync<TOutput, BaseError>;
+type ServiceEventHandler<TEvent, TDeps = undefined> = (args: { event: TEvent; context: EventListenerContext; client: HandlerClient } & WithDeps<TDeps>) => MaybeAsync<void, BaseError>;
+
+type RpcHandler<TInput, TOutput, TDeps = undefined> = (args: { input: TInput; context: RpcHandlerContext; client: HandlerClient } & WithDeps<TDeps>) => MaybeAsync<TOutput, BaseError>;
+
+type FeedHandler<TInput, TEvent, TDeps = undefined> = (context: { input: TInput; caller: unknown; signal: AbortSignal; emit(event: TEvent): AsyncResult<void, ValidationError | UnexpectedError>; client: HandlerClient } & WithDeps<TDeps>) => unknown | Promise<unknown>;
+
+type OperationHandler<TInput, TProgress, TOutput, TTransfer, TDeps = undefined> = (context: { input: TInput; op: OperationRuntimeHandle<TProgress, TOutput>; caller: unknown; client: HandlerClient } & TTransfer & WithDeps<TDeps>) => unknown | Promise<unknown>;
 
 export type TrellisJobsState = {};
 
@@ -52,22 +60,35 @@ export interface TrellisJobsClient {
   wait(): AsyncResult<void, BaseError>;
 }
 
-export interface Service extends Client {
+export interface Service extends TrellisJobsClient {
   readonly handle: ServiceHandle;
+  with<TDeps>(deps: TDeps): ServiceWithDeps<TDeps>;
+}
+
+export type ServiceWithDeps<TDeps> = Omit<TrellisJobsClient, "event"> & {
+  readonly event: ServiceEventSurface<TDeps>;
+  readonly handle: ServiceHandle<TDeps>;
+  with<TNextDeps>(deps: TNextDeps): ServiceWithDeps<TNextDeps>;
+};
+
+export interface ServiceEventSurface<TDeps> {
+  readonly health: {
+    heartbeat: { publish(event: Omit<HealthSdk.HealthHeartbeatEvent, "header">): AsyncResult<void, ValidationError | UnexpectedError>; prepare(event: Omit<HealthSdk.HealthHeartbeatEvent, "header">): Result<PreparedTrellisEvent<Omit<HealthSdk.HealthHeartbeatEvent, "header">>, ValidationError | UnexpectedError>; listen(handler: ServiceEventHandler<HealthSdk.HealthHeartbeatEvent, TDeps>, subjectData?: Record<string, unknown>, opts?: EventOpts): AsyncResult<void, ValidationError | UnexpectedError>; };
+  };
 }
 
-export interface ServiceHandle {
+export interface ServiceHandle<TDeps = undefined> {
   readonly rpc: {
     readonly jobs: {
-      cancel(handler: RpcHandler<Types.JobsCancelInput, Types.JobsCancelOutput>): Promise<void>;
-      dismissDLQ(handler: RpcHandler<Types.JobsDismissDLQInput, Types.JobsDismissDLQOutput>): Promise<void>;
-      get(handler: RpcHandler<Types.JobsGetInput, Types.JobsGetOutput>): Promise<void>;
-      health(handler: RpcHandler<Types.JobsHealthInput, Types.JobsHealthOutput>): Promise<void>;
-      list(handler: RpcHandler<Types.JobsListInput, Types.JobsListOutput>): Promise<void>;
-      listDLQ(handler: RpcHandler<Types.JobsListDLQInput, Types.JobsListDLQOutput>): Promise<void>;
-      listServices(handler: RpcHandler<Types.JobsListServicesInput, Types.JobsListServicesOutput>): Promise<void>;
-      replayDLQ(handler: RpcHandler<Types.JobsReplayDLQInput, Types.JobsReplayDLQOutput>): Promise<void>;
-      retry(handler: RpcHandler<Types.JobsRetryInput, Types.JobsRetryOutput>): Promise<void>;
+      cancel(handler: RpcHandler<Types.JobsCancelInput, Types.JobsCancelOutput, TDeps>): Promise<void>;
+      dismissDLQ(handler: RpcHandler<Types.JobsDismissDLQInput, Types.JobsDismissDLQOutput, TDeps>): Promise<void>;
+      get(handler: RpcHandler<Types.JobsGetInput, Types.JobsGetOutput, TDeps>): Promise<void>;
+      health(handler: RpcHandler<Types.JobsHealthInput, Types.JobsHealthOutput, TDeps>): Promise<void>;
+      list(handler: RpcHandler<Types.JobsListInput, Types.JobsListOutput, TDeps>): Promise<void>;
+      listDLQ(handler: RpcHandler<Types.JobsListDLQInput, Types.JobsListDLQOutput, TDeps>): Promise<void>;
+      listServices(handler: RpcHandler<Types.JobsListServicesInput, Types.JobsListServicesOutput, TDeps>): Promise<void>;
+      replayDLQ(handler: RpcHandler<Types.JobsReplayDLQInput, Types.JobsReplayDLQOutput, TDeps>): Promise<void>;
+      retry(handler: RpcHandler<Types.JobsRetryInput, Types.JobsRetryOutput, TDeps>): Promise<void>;
     };
   };
   readonly feed: {};

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

@@ -2,5 +2,5 @@ export { API, OWNED_API } from "./api.js";
 export type { Api, ApiViews, OwnedApi } from "./api.js";
 export * from "./types.js";
 export * from "./schemas.js";
-export type { Client, HandlerClient, TrellisJobsClient, TrellisJobsState } from "./client.js";
+export type { Client, HandlerClient, Service, ServiceEventSurface, ServiceHandle, ServiceWithDeps, TrellisJobsClient, TrellisJobsState } from "./client.js";
 export { CONTRACT, CONTRACT_DIGEST, CONTRACT_ID, use, sdk } from "./contract.js";

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

@@ -1,14 +1,22 @@
 // Generated from ./generated/contracts/manifests/trellis.state@v1.json
-import type { AcceptedOperation, AsyncResult, BaseError, EventOpts, FeedSubscribeOpts, FeedSubscription, HandlerTrellis, MapStateStoreClient, MaybeAsync, OperationInputBuilder, OperationObserverCallbacks, OperationRef, OperationRefData, OperationRuntimeHandle, PreparedTrellisEvent, ReceiveTransferGrant, ReceiveTransferHandle, RequestOpts, Result, RpcHandlerContext, SendTransferGrant, SendTransferHandle, TerminalOperation, TransferCapableOperationInputBuilder, TrellisConnection, UnexpectedError, ValidationError, ValueStateStoreClient } from "../../../index.js";
+import type { AcceptedOperation, AsyncResult, BaseError, EventListenerContext, EventOpts, FeedSubscribeOpts, FeedSubscription, HandlerTrellis, MapStateStoreClient, MaybeAsync, OperationInputBuilder, OperationObserverCallbacks, OperationRef, OperationRefData, OperationRuntimeHandle, OperationTransferHandle, PreparedTrellisEvent, ReceiveTransferGrant, ReceiveTransferHandle, RequestOpts, Result, RpcHandlerContext, SendTransferGrant, SendTransferHandle, TerminalOperation, TransferCapableOperationInputBuilder, TrellisConnection, UnexpectedError, ValidationError, ValueStateStoreClient } from "../../../index.js";
 import type { API, Api } from "./api.js";
 import type * as Types from "./types.js";
 import type * as HealthSdk from "../health/mod.js";
 
+type WithDeps<TDeps> = [TDeps] extends [undefined] ? {} : { deps: TDeps };
+
 type EventCallback<TMessage> = {
-  bivarianceHack(message: TMessage): MaybeAsync<void, BaseError>;
+  bivarianceHack(message: TMessage, context: EventListenerContext): MaybeAsync<void, BaseError>;
 }["bivarianceHack"];
 
-type RpcHandler<TInput, TOutput> = (args: { input: TInput; context: RpcHandlerContext; client: HandlerClient }) => MaybeAsync<TOutput, BaseError>;
+type ServiceEventHandler<TEvent, TDeps = undefined> = (args: { event: TEvent; context: EventListenerContext; client: HandlerClient } & WithDeps<TDeps>) => MaybeAsync<void, BaseError>;
+
+type RpcHandler<TInput, TOutput, TDeps = undefined> = (args: { input: TInput; context: RpcHandlerContext; client: HandlerClient } & WithDeps<TDeps>) => MaybeAsync<TOutput, BaseError>;
+
+type FeedHandler<TInput, TEvent, TDeps = undefined> = (context: { input: TInput; caller: unknown; signal: AbortSignal; emit(event: TEvent): AsyncResult<void, ValidationError | UnexpectedError>; client: HandlerClient } & WithDeps<TDeps>) => unknown | Promise<unknown>;
+
+type OperationHandler<TInput, TProgress, TOutput, TTransfer, TDeps = undefined> = (context: { input: TInput; op: OperationRuntimeHandle<TProgress, TOutput>; caller: unknown; client: HandlerClient } & TTransfer & WithDeps<TDeps>) => unknown | Promise<unknown>;
 
 export type TrellisStateState = {};
 
@@ -42,20 +50,33 @@ export interface TrellisStateClient {
   wait(): AsyncResult<void, BaseError>;
 }
 
-export interface Service extends Client {
+export interface Service extends TrellisStateClient {
   readonly handle: ServiceHandle;
+  with<TDeps>(deps: TDeps): ServiceWithDeps<TDeps>;
+}
+
+export type ServiceWithDeps<TDeps> = Omit<TrellisStateClient, "event"> & {
+  readonly event: ServiceEventSurface<TDeps>;
+  readonly handle: ServiceHandle<TDeps>;
+  with<TNextDeps>(deps: TNextDeps): ServiceWithDeps<TNextDeps>;
+};
+
+export interface ServiceEventSurface<TDeps> {
+  readonly health: {
+    heartbeat: { publish(event: Omit<HealthSdk.HealthHeartbeatEvent, "header">): AsyncResult<void, ValidationError | UnexpectedError>; prepare(event: Omit<HealthSdk.HealthHeartbeatEvent, "header">): Result<PreparedTrellisEvent<Omit<HealthSdk.HealthHeartbeatEvent, "header">>, ValidationError | UnexpectedError>; listen(handler: ServiceEventHandler<HealthSdk.HealthHeartbeatEvent, TDeps>, subjectData?: Record<string, unknown>, opts?: EventOpts): AsyncResult<void, ValidationError | UnexpectedError>; };
+  };
 }
 
-export interface ServiceHandle {
+export interface ServiceHandle<TDeps = undefined> {
   readonly rpc: {
     readonly state: {
-      adminDelete(handler: RpcHandler<Types.StateAdminDeleteInput, Types.StateAdminDeleteOutput>): Promise<void>;
-      adminGet(handler: RpcHandler<Types.StateAdminGetInput, Types.StateAdminGetOutput>): Promise<void>;
-      adminList(handler: RpcHandler<Types.StateAdminListInput, Types.StateAdminListOutput>): Promise<void>;
-      delete(handler: RpcHandler<Types.StateDeleteInput, Types.StateDeleteOutput>): Promise<void>;
-      get(handler: RpcHandler<Types.StateGetInput, Types.StateGetOutput>): Promise<void>;
-      list(handler: RpcHandler<Types.StateListInput, Types.StateListOutput>): Promise<void>;
-      put(handler: RpcHandler<Types.StatePutInput, Types.StatePutOutput>): Promise<void>;
+      adminDelete(handler: RpcHandler<Types.StateAdminDeleteInput, Types.StateAdminDeleteOutput, TDeps>): Promise<void>;
+      adminGet(handler: RpcHandler<Types.StateAdminGetInput, Types.StateAdminGetOutput, TDeps>): Promise<void>;
+      adminList(handler: RpcHandler<Types.StateAdminListInput, Types.StateAdminListOutput, TDeps>): Promise<void>;
+      delete(handler: RpcHandler<Types.StateDeleteInput, Types.StateDeleteOutput, TDeps>): Promise<void>;
+      get(handler: RpcHandler<Types.StateGetInput, Types.StateGetOutput, TDeps>): Promise<void>;
+      list(handler: RpcHandler<Types.StateListInput, Types.StateListOutput, TDeps>): Promise<void>;
+      put(handler: RpcHandler<Types.StatePutInput, Types.StatePutOutput, TDeps>): Promise<void>;
     };
   };
   readonly feed: {};

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

@@ -2,5 +2,5 @@ export { API, OWNED_API } from "./api.js";
 export type { Api, ApiViews, OwnedApi } from "./api.js";
 export * from "./types.js";
 export * from "./schemas.js";
-export type { Client, HandlerClient, TrellisStateClient, TrellisStateState } from "./client.js";
+export type { Client, HandlerClient, Service, ServiceEventSurface, ServiceHandle, ServiceWithDeps, TrellisStateClient, TrellisStateState } from "./client.js";
 export { CONTRACT, CONTRACT_DIGEST, CONTRACT_ID, use, sdk } from "./contract.js";