@qlever-llc/trellis 0.10.2 → 0.10.3-rc.4

package/script/npm/src/trellis.d.ts

@@ -1,678 +0,0 @@
-import { type JetStreamClient } from "@nats-io/jetstream";
-import { type Msg, type NatsConnection } from "@nats-io/nats-core";
-import type { EventDesc, FeedDesc, InferSchemaType, TrellisAPI } from "./contracts.js";
-import { CONTRACT_JOBS_METADATA, CONTRACT_KV_METADATA, CONTRACT_STATE_METADATA, type ContractEventConsumers, type ContractJobsMetadata, type ContractKvMetadata, type EventConsumerResourceBinding } from "./contract_support/mod.js";
-import type { StaticDecode } from "typebox";
-import { AuthRequestsValidateResponseSchema, AuthRequestsValidateSchema } from "./auth/protocol.js";
-import { AsyncResult, BaseError, type MaybeAsync, Result } from "@qlever-llc/result";
-import { Type } from "typebox";
-import { type JsonValue } from "./codec.js";
-import { AuthError, type StoreError, TransferError, TransportError, type TrellisErrorInstance, type TrellisErrorMap, type TrellisErrorName, UnexpectedError, ValidationError } from "./errors/index.js";
-import { RemoteError } from "./errors/RemoteError.js";
-import { type LoggerLike } from "./globals.js";
-import { TypedKV } from "./kv.js";
-import type { ActiveJob, JobRef, JobTypeMetadata } from "./jobs.js";
-import type { StoreWaitOptions, TypedStore, TypedStoreEntry } from "./store.js";
-import { OperationInvoker, type OperationRefData } from "./operations.js";
-import { type FileInfo, type ReceiveTransferGrant, type ReceiveTransferHandle, type SendTransferGrant, type SendTransferHandle } from "./transfer.js";
-import { TrellisConnection } from "./connection.js";
-export type { NatsConnection } from "@nats-io/nats-core";
-type InferRuntimeRpcError<T> = T extends {
-    fromSerializable(data: unknown): infer TError;
-} ? TError : never;
-export type AuthRequestsValidateResponse = StaticDecode<typeof AuthRequestsValidateResponseSchema>;
-export type AuthRequestsValidateInput = StaticDecode<typeof AuthRequestsValidateSchema>;
-export type SessionCaller = AuthRequestsValidateResponse["caller"];
-/**
- * Safely extract JSON from a NATS message.
- * The .json() method can throw if the message data is not valid JSON.
- */
-export declare function safeJson(msg: Msg): Result<JsonValue, UnexpectedError>;
-export declare function base64urlEncode(data: Uint8Array): string;
-export declare function base64urlDecode(s: string): Uint8Array;
-export declare function toArrayBuffer(data: Uint8Array): ArrayBuffer;
-export declare function sha256(data: Uint8Array): Promise<Uint8Array>;
-export declare function buildProofInput(sessionKey: string, subject: string, payloadHash: Uint8Array, iat: number, requestId: string): Uint8Array;
-export type TrellisSigner = (data: Uint8Array) => Promise<Uint8Array> | Uint8Array;
-export type TrellisAuth = {
-    sessionKey: string;
-    sign: TrellisSigner;
-    currentIat?: () => number;
-};
-export type AnyTrellisAPI = TrellisAPI;
-export type TrellisMode = "client" | "server";
-type Simplify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-type OwnedApiFor<TContract> = TContract extends {
-    API: {
-        owned: infer TOwnedApi;
-    };
-} ? TOwnedApi extends AnyTrellisAPI ? TOwnedApi : never : never;
-type ContractKvFor<TContract> = TContract extends {
-    readonly [CONTRACT_KV_METADATA]?: infer TKv;
-} ? NonNullable<TKv> extends ContractKvMetadata ? NonNullable<TKv> : {} : {};
-type ContractJobsFor<TContract> = TContract extends {
-    readonly [CONTRACT_JOBS_METADATA]?: infer TJobs;
-} ? NonNullable<TJobs> extends ContractJobsMetadata ? NonNullable<TJobs> : {} : {};
-export type RuntimeStateStoreShape = {
-    kind: "value" | "map";
-    value: unknown;
-    schema?: unknown;
-    stateVersion?: string;
-    acceptedVersions?: Record<string, unknown>;
-};
-export type RuntimeStateStores = Record<string, RuntimeStateStoreShape>;
-export type RuntimeStateStoresForContract<TContract> = TContract extends {
-    readonly [CONTRACT_STATE_METADATA]?: infer TState;
-} ? NonNullable<TState> extends RuntimeStateStores ? NonNullable<TState> : {} : {};
-type TrellisApiFor<TContract> = TContract extends {
-    API: {
-        trellis?: infer TTrellisApi;
-    };
-} ? NonNullable<TTrellisApi> extends AnyTrellisAPI ? NonNullable<TTrellisApi> : OwnedApiFor<TContract> : OwnedApiFor<TContract>;
-type RpcMethodsOf<TA extends AnyTrellisAPI> = TA["rpc"];
-export type MethodsOf<TA extends AnyTrellisAPI> = keyof RpcMethodsOf<TA> & string;
-export type RpcMethodNameOf<TA extends AnyTrellisAPI> = MethodsOf<TA>;
-export type OperationsOf<TA extends AnyTrellisAPI> = keyof TA["operations"] & string;
-type EventsOf<TA extends AnyTrellisAPI> = keyof TA["events"] & string;
-export type FeedsOf<TA extends AnyTrellisAPI> = keyof NonNullable<TA["feeds"]> & string;
-type RpcMethodOf<TA extends AnyTrellisAPI, M extends keyof TA["rpc"] & string> = RpcMethodsOf<TA>[M];
-type MethodInputOf<TA extends AnyTrellisAPI, M extends keyof TA["rpc"] & string> = RpcMethodOf<TA, M> extends {
-    input: infer TInput;
-} ? InferSchemaType<TInput> : never;
-export type RpcInputOf<TA extends AnyTrellisAPI, M extends RpcMethodNameOf<TA>> = MethodInputOf<TA, M>;
-type MethodOutputOf<TA extends AnyTrellisAPI, M extends keyof TA["rpc"] & string> = RpcMethodOf<TA, M> extends {
-    output: infer TOutput;
-} ? InferSchemaType<TOutput> : never;
-export type RpcOutputOf<TA extends AnyTrellisAPI, M extends RpcMethodNameOf<TA>> = MethodOutputOf<TA, M>;
-type RpcRequestShapes<TA extends AnyTrellisAPI> = {
-    [M in keyof TA["rpc"] & string]: {
-        input: MethodInputOf<TA, M>;
-        output: MethodOutputOf<TA, M>;
-    };
-};
-type RequestMethodOf<TRequests> = keyof TRequests & string;
-type RequestInputOf<TRequests, M extends RequestMethodOf<TRequests>> = TRequests[M] extends {
-    input: infer TInput;
-} ? TInput : never;
-type RequestOutputOf<TRequests, M extends RequestMethodOf<TRequests>> = TRequests[M] extends {
-    output: infer TOutput;
-} ? TOutput : never;
-type RpcDescriptorOf<TA extends AnyTrellisAPI, M extends keyof TA["rpc"] & string> = RpcMethodOf<TA, M> extends {
-    input: infer TInput;
-    output: infer TOutput;
-    errors?: infer TErrors;
-    runtimeErrors?: infer TRuntimeErrors;
-    declaredErrorTypes?: infer TDeclaredErrorTypes;
-} ? {
-    input: TInput;
-    output: TOutput;
-    errors?: TErrors;
-    runtimeErrors?: TRuntimeErrors;
-    declaredErrorTypes?: TDeclaredErrorTypes;
-} & RpcMethodOf<TA, M> : never;
-type DeclaredBuiltinErrorOf<TNames> = TNames extends readonly (infer TName)[] ? TName extends TrellisErrorName ? TrellisErrorMap[TName] : never : never;
-type DeclaredRuntimeErrorOf<TRuntimeErrors> = TRuntimeErrors extends readonly (infer TRuntimeError)[] ? InferRuntimeRpcError<TRuntimeError> : never;
-type MethodDeclaredErrorOf<TA extends AnyTrellisAPI, M extends keyof TA["rpc"] & string> = RpcDescriptorOf<TA, M> extends {
-    errors?: infer TErrors;
-    runtimeErrors?: infer TRuntimeErrors;
-} ? DeclaredBuiltinErrorOf<TErrors> | DeclaredRuntimeErrorOf<TRuntimeErrors> : never;
-type RequestErrorOf<TA extends AnyTrellisAPI, M extends MethodsOf<TA>> = MethodDeclaredErrorOf<TA, M> | RemoteError | TransportError | ValidationError | UnexpectedError;
-type HandlerErrorOf<TA extends AnyTrellisAPI, M extends MethodsOf<TA>> = MethodDeclaredErrorOf<TA, M> | TrellisErrorInstance;
-type EventOf<TA extends AnyTrellisAPI, E extends EventsOf<TA>> = TA["events"][E] extends EventDesc<infer TEvent> ? InferSchemaType<TEvent> : never;
-type EventPayloadOf<TA extends AnyTrellisAPI, E extends EventsOf<TA>> = Omit<EventOf<TA, E>, "header">;
-/** A fully encoded event whose subject, payload, and headers are stable. */
-export type PreparedTrellisEvent<TPayload extends Record<string, unknown> = Record<string, unknown>> = Readonly<{
-    event: string;
-    subject: string;
-    payload: Readonly<TPayload & {
-        header: {
-            id: string;
-            time: string;
-        };
-    }>;
-    encodedPayload: string;
-    headers: Readonly<Record<string, string>>;
-}>;
-export type FeedInputOf<TA extends AnyTrellisAPI, F extends FeedsOf<TA>> = NonNullable<TA["feeds"]>[F] extends FeedDesc<infer TInput, infer _TEvent> ? InferSchemaType<TInput> : never;
-export type FeedEventOf<TA extends AnyTrellisAPI, F extends FeedsOf<TA>> = NonNullable<TA["feeds"]>[F] extends FeedDesc<infer _TInput, infer TEvent> ? InferSchemaType<TEvent> : never;
-export type OperationInputOf<TA extends AnyTrellisAPI, O extends OperationsOf<TA>> = TA["operations"][O] extends {
-    input: infer TInput;
-} ? InferSchemaType<TInput> : never;
-export type OperationProgressOf<TA extends AnyTrellisAPI, O extends OperationsOf<TA>> = TA["operations"][O] extends {
-    progress: infer TProgress;
-} ? TProgress extends undefined ? unknown : InferSchemaType<NonNullable<TProgress>> : unknown;
-export type OperationOutputOf<TA extends AnyTrellisAPI, O extends OperationsOf<TA>> = TA["operations"][O] extends {
-    output: infer TOutput;
-} ? TOutput extends undefined ? unknown : InferSchemaType<NonNullable<TOutput>> : unknown;
-export type OperationRuntimeHandle<TProgress = unknown, TOutput = unknown> = {
-    id: string;
-    started(): AsyncResult<RuntimeOperationSnapshot, BaseError>;
-    progress(value: TProgress): AsyncResult<RuntimeOperationSnapshot, BaseError>;
-    complete(value: TOutput): AsyncResult<RuntimeOperationSnapshot, BaseError>;
-    fail(error: BaseError): AsyncResult<RuntimeOperationSnapshot, BaseError>;
-    cancel(): AsyncResult<RuntimeOperationSnapshot, BaseError>;
-    attach(job: {
-        wait(): AsyncResult<unknown, BaseError>;
-    }): AsyncResult<RuntimeOperationSnapshot, BaseError>;
-    signals(): AsyncIterable<RuntimeOperationSignal>;
-    nextSignal(name?: string): AsyncResult<RuntimeOperationSignal, BaseError>;
-    defer(): OperationDeferred;
-};
-export type OperationDeferred = {
-    kind: "deferred";
-};
-/**
- * Returns true when a handler result explicitly leaves operation completion to
- * an external control path.
- */
-export declare function isOperationDeferred(value: unknown): value is OperationDeferred;
-export type AcceptedOperation<TProgress = unknown, TOutput = unknown> = OperationRuntimeHandle<TProgress, TOutput> & {
-    ref: OperationRefData;
-    snapshot: RuntimeOperationSnapshot & {
-        progress?: TProgress;
-        output?: TOutput;
-    };
-};
-export type OperationTransferHandle = {
-    updates(): AsyncIterable<RuntimeOperationTransferProgress>;
-    completed(): AsyncResult<FileInfo, TransferError>;
-};
-type StateEntryBase<TValue> = {
-    value: TValue;
-    revision: string;
-    updatedAt: string;
-    expiresAt?: string;
-};
-type ValueStateEntry<TValue> = StateEntryBase<TValue>;
-type MapStateEntry<TValue> = StateEntryBase<TValue> & {
-    key: string;
-};
-type StateMigrationRequiredEntry<TEntry> = {
-    migrationRequired: true;
-    entry: TEntry;
-    stateVersion: string;
-    currentStateVersion: string;
-    writerContractDigest: string;
-};
-type StateGetResult<TStore extends RuntimeStateStoreShape> = {
-    found: false;
-} | {
-    found: true;
-    entry: TStore["kind"] extends "map" ? MapStateEntry<TStore["value"]> : ValueStateEntry<TStore["value"]>;
-} | StateMigrationRequiredEntry<TStore["kind"] extends "map" ? MapStateEntry<unknown> : ValueStateEntry<unknown>>;
-type StatePutResult<TStore extends RuntimeStateStoreShape> = {
-    applied: true;
-    entry: TStore["kind"] extends "map" ? MapStateEntry<TStore["value"]> : ValueStateEntry<TStore["value"]>;
-} | {
-    applied: false;
-    found: boolean;
-    entry?: (TStore["kind"] extends "map" ? MapStateEntry<TStore["value"]> : ValueStateEntry<TStore["value"]>) | StateMigrationRequiredEntry<TStore["kind"] extends "map" ? MapStateEntry<unknown> : ValueStateEntry<unknown>>;
-};
-type StateDeleteOptions = {
-    expectedRevision?: string;
-};
-type StatePutOptions = {
-    expectedRevision?: string | null;
-    ttlMs?: number;
-};
-type StateListOptions = {
-    offset?: number;
-    limit?: number;
-};
-export type ValueStateStoreClient<TValue> = {
-    get(): AsyncResult<StateGetResult<{
-        kind: "value";
-        value: TValue;
-    }>, BaseError>;
-    put(value: TValue, opts?: StatePutOptions): AsyncResult<StatePutResult<{
-        kind: "value";
-        value: TValue;
-    }>, BaseError>;
-    delete(opts?: StateDeleteOptions): AsyncResult<{
-        deleted: boolean;
-    }, BaseError>;
-};
-export type MapStateStoreClient<TValue> = {
-    get(key: string): AsyncResult<StateGetResult<{
-        kind: "map";
-        value: TValue;
-    }>, BaseError>;
-    put(key: string, value: TValue, opts?: StatePutOptions): AsyncResult<StatePutResult<{
-        kind: "map";
-        value: TValue;
-    }>, BaseError>;
-    delete(key: string, opts?: StateDeleteOptions): AsyncResult<{
-        deleted: boolean;
-    }, BaseError>;
-    list(opts?: StateListOptions): AsyncResult<{
-        entries: Array<MapStateEntry<TValue> | StateMigrationRequiredEntry<MapStateEntry<unknown>>>;
-        count: number;
-        offset: number;
-        limit: number;
-        nextOffset?: number;
-    }, BaseError>;
-    prefix(path: string): MapStateStoreClient<TValue>;
-};
-export type StateFacade<TState extends RuntimeStateStores> = {
-    [K in keyof TState]: TState[K]["kind"] extends "map" ? MapStateStoreClient<TState[K]["value"]> : ValueStateStoreClient<TState[K]["value"]>;
-};
-export type OperationHandlerContext<TInput, TProgress = unknown, TOutput = unknown, TTransfer = undefined> = {
-    input: TInput;
-    op: OperationRuntimeHandle<TProgress, TOutput>;
-    caller: SessionCaller;
-} & (TTransfer extends undefined ? {} : {
-    transfer: TTransfer;
-});
-export type OperationRegistration<TInput, TProgress = unknown, TOutput = unknown, TTransfer = undefined> = {
-    accept(args: {
-        sessionKey: string;
-    }): AsyncResult<AcceptedOperation<TProgress, TOutput>, UnexpectedError>;
-    /**
-     * Loads an existing operation by id and returns a service-side control handle.
-     * The operation must belong to this service and registration name.
-     */
-    control(operationId: string): AsyncResult<OperationRuntimeHandle<TProgress, TOutput>, BaseError>;
-    handle(handler: (context: OperationHandlerContext<TInput, TProgress, TOutput, TTransfer>) => unknown | Promise<unknown>): Promise<void>;
-};
-export type OperationTransferContextOf<TA extends AnyTrellisAPI, O extends OperationsOf<TA>> = TA["operations"][O] extends {
-    transfer: infer TTransfer;
-} ? TTransfer extends undefined ? undefined : OperationTransferHandle : undefined;
-export type OperationSurface<TA extends AnyTrellisAPI, TMode extends TrellisMode, O extends OperationsOf<TA>> = TMode extends "server" ? OperationRegistration<OperationInputOf<TA, O>, OperationProgressOf<TA, O>, OperationOutputOf<TA, O>, OperationTransferContextOf<TA, O>> : OperationInvoker<TA["operations"][O] & RuntimeOperationDesc>;
-export declare function isResultLike(value: unknown): value is Result<unknown, BaseError>;
-export type RuntimeOperationDesc = {
-    subject: string;
-    input: unknown;
-    progress?: unknown;
-    output?: unknown;
-    signals?: Record<string, {
-        input: unknown;
-    }>;
-    cancelCapabilities?: readonly string[];
-    controlCapabilities?: readonly string[];
-    transfer?: {
-        store: string;
-        key: `/${string}`;
-        contentType?: `/${string}`;
-        metadata?: `/${string}`;
-        expiresInMs?: number;
-        maxBytes?: number;
-    };
-    cancel?: boolean;
-};
-export type RuntimeOperationSignal = {
-    operationId: string;
-    sequence: number;
-    signal: string;
-    input?: JsonValue;
-    acceptedAt: string;
-};
-export type RuntimeOperationSignalWaiter = (result: Result<RuntimeOperationSignal, BaseError>) => void;
-export type RuntimeOperationTransferProgress = {
-    chunkIndex: number;
-    chunkBytes: number;
-    transferredBytes: number;
-};
-export type RuntimeOperationState = "pending" | "running" | "completed" | "failed" | "cancelled";
-export type RuntimeOperationSnapshot = {
-    id: string;
-    service: string;
-    operation: string;
-    revision: number;
-    state: RuntimeOperationState;
-    createdAt: string;
-    updatedAt: string;
-    completedAt?: string;
-    progress?: unknown;
-    transfer?: RuntimeOperationTransferProgress;
-    output?: unknown;
-    error?: {
-        type: string;
-        message: string;
-    };
-};
-export type RuntimeOperationRecord = {
-    id: string;
-    service: string;
-    operation: string;
-    ownerSessionKey: string;
-    snapshot: RuntimeOperationSnapshot;
-    sequence: number;
-    signalSequence: number;
-    signals: RuntimeOperationSignal[];
-    terminal: boolean;
-    watchers: Set<string>;
-    waiters: Set<string>;
-    signalWaiters: Set<RuntimeOperationSignalWaiter>;
-};
-export type DurableOperationRecord = {
-    ownerSessionKey: string;
-    sequence: number;
-    signalSequence?: number;
-    signals?: RuntimeOperationSignal[];
-    snapshot: RuntimeOperationSnapshot;
-};
-export declare const DurableOperationRecordSchema: Type.TObject<{
-    ownerSessionKey: Type.TString;
-    sequence: Type.TNumber;
-    signalSequence: Type.TOptional<Type.TNumber>;
-    signals: Type.TOptional<Type.TArray<Type.TObject<{
-        operationId: Type.TString;
-        sequence: Type.TNumber;
-        signal: Type.TString;
-        input: Type.TOptional<Type.TAny>;
-        acceptedAt: Type.TString;
-    }>>>;
-    snapshot: Type.TObject<{
-        id: Type.TString;
-        service: Type.TString;
-        operation: Type.TString;
-        revision: Type.TNumber;
-        state: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"running">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"cancelled">]>;
-        createdAt: Type.TString;
-        updatedAt: Type.TString;
-        completedAt: Type.TOptional<Type.TString>;
-        progress: Type.TOptional<Type.TAny>;
-        transfer: Type.TOptional<Type.TObject<{
-            chunkIndex: Type.TNumber;
-            chunkBytes: Type.TNumber;
-            transferredBytes: Type.TNumber;
-        }>>;
-        output: Type.TOptional<Type.TAny>;
-        error: Type.TOptional<Type.TObject<{
-            type: Type.TString;
-            message: Type.TString;
-        }>>;
-    }>;
-}>;
-export type RuntimeOperationAcceptedEnvelope = {
-    kind: "accepted";
-    ref: OperationRefData;
-    snapshot: RuntimeOperationSnapshot;
-    transfer?: SendTransferGrant;
-};
-export type RuntimeOperationControlRequest = {
-    action: "get" | "wait" | "watch" | "cancel";
-    operationId: string;
-} | {
-    action: "signal";
-    operationId: string;
-    signal: string;
-    input?: JsonValue;
-};
-export type RuntimeOperationController = {
-    get(operationId: string): AsyncResult<RuntimeOperationSnapshot, BaseError>;
-    started(operationId: string): AsyncResult<RuntimeOperationSnapshot, BaseError>;
-    progress(operationId: string, progress: unknown): AsyncResult<RuntimeOperationSnapshot, BaseError>;
-    complete(operationId: string, output: unknown): AsyncResult<RuntimeOperationSnapshot, BaseError>;
-    fail(operationId: string, error: BaseError): AsyncResult<RuntimeOperationSnapshot, BaseError>;
-    cancel(operationId: string): AsyncResult<RuntimeOperationSnapshot, BaseError>;
-    signals(operationId: string): AsyncIterable<RuntimeOperationSignal>;
-    nextSignal(operationId: string, name?: string): AsyncResult<RuntimeOperationSignal, BaseError>;
-};
-export declare function buildRuntimeOperationSnapshot(runtime: Pick<RuntimeOperationRecord, "id" | "service" | "operation" | "snapshot">, state: RuntimeOperationState, patch?: Partial<RuntimeOperationSnapshot>): RuntimeOperationSnapshot;
-export declare function isTerminalRuntimeOperationSnapshot(value: unknown): value is RuntimeOperationSnapshot;
-type NoResponderRetryOpts = {
-    maxAttempts?: number;
-    baseDelayMs?: number;
-};
-export type TrellisOpts<TA extends AnyTrellisAPI> = {
-    log?: LoggerLike;
-    timeout?: number;
-    stream?: string;
-    noResponderRetry?: NoResponderRetryOpts;
-    api?: TA;
-    state?: RuntimeStateStores;
-    connection?: TrellisConnection;
-    onSessionNotFound?: () => MaybePromise<void>;
-};
-export type RequestOpts = {
-    timeout?: number;
-};
-export type EventOpts = {
-    mode?: "durable" | "ephemeral";
-    replay?: "all" | "new";
-    /**
-     * Contract event consumer group to use for durable service listeners when an
-     * event is declared in more than one group.
-     */
-    group?: string;
-    /** @deprecated Durable service listener names are provisioned by Trellis bindings. */
-    durableName?: string;
-    signal?: AbortSignal;
-};
-type RuntimeEventConsumers = {
-    metadata?: ContractEventConsumers;
-    bindings?: Record<string, EventConsumerResourceBinding>;
-};
-type TrellisInternalOpts<TA extends AnyTrellisAPI> = TrellisOpts<TA> & {
-    eventConsumers?: RuntimeEventConsumers;
-};
-/**
- * Creates a Trellis runtime with bootstrap-resolved bindings.
- *
- * @internal
- */
-export declare function createTrellisInternal<TA extends AnyTrellisAPI = TrellisAPI, TMode extends TrellisMode = "client", TState extends RuntimeStateStores = RuntimeStateStores>(name: string, nats: NatsConnection, auth: TrellisAuth, opts?: TrellisInternalOpts<TA>): Trellis<TA, TMode, TState>;
-export type FeedSubscribeOpts = {
-    signal?: AbortSignal;
-};
-export type FeedSubscription<TEvent> = AsyncIterable<TEvent>;
-export type FeedInputBuilder<TInput, TEvent> = {
-    input(input: TInput): {
-        subscribe(opts?: FeedSubscribeOpts): AsyncResult<FeedSubscription<TEvent>, BaseError>;
-    };
-};
-export type FeedHandlerContext<TInput, TEvent> = {
-    input: TInput;
-    caller: SessionCaller;
-    signal: AbortSignal;
-    emit(event: TEvent): AsyncResult<void, ValidationError | UnexpectedError>;
-};
-export type FeedRegistration<TInput, TEvent> = {
-    handle(handler: (context: FeedHandlerContext<TInput, TEvent>) => unknown | Promise<unknown>): Promise<void>;
-};
-type PascalSurfaceName<T extends string> = T extends `${infer Head}.${infer Tail}` ? `${Capitalize<Head>}${PascalSurfaceName<Tail>}` : Capitalize<T>;
-type LowerCamelSurfaceName<T extends string> = Uncapitalize<PascalSurfaceName<T>>;
-type SurfaceGroupName<T extends string> = T extends `${infer Head}.${string}` ? LowerCamelSurfaceName<Head> : LowerCamelSurfaceName<T>;
-type SurfaceLeafName<T extends string> = T extends `${string}.${infer Tail}` ? LowerCamelSurfaceName<Tail> : LowerCamelSurfaceName<T>;
-type SurfaceKeysForGroup<TKeys extends string, TGroup extends string> = TKeys extends string ? SurfaceGroupName<TKeys> extends TGroup ? TKeys : never : never;
-export type ActiveRpcFacade<TA extends AnyTrellisAPI = TrellisAPI> = {
-    readonly [TGroup in SurfaceGroupName<MethodsOf<TA>>]: {
-        readonly [M in SurfaceKeysForGroup<MethodsOf<TA>, TGroup> as SurfaceLeafName<M>]: (input: RpcInputOf<TA, M>, opts?: RequestOpts) => AsyncResult<RpcOutputOf<TA, M>, BaseError>;
-    };
-};
-export type ActiveEventFacade<TA extends AnyTrellisAPI = TrellisAPI> = {
-    readonly [TGroup in SurfaceGroupName<EventsOf<TA>>]: {
-        readonly [E in SurfaceKeysForGroup<EventsOf<TA>, TGroup> as SurfaceLeafName<E>]: {
-            prepare(event: EventPayloadOf<TA, E>): Result<PreparedTrellisEvent<EventPayloadOf<TA, E>>, ValidationError | UnexpectedError>;
-            publish(event: EventPayloadOf<TA, E>): AsyncResult<void, ValidationError | UnexpectedError>;
-            listen(handler: EventCallback<EventOf<TA, E>>, subjectData?: Record<string, unknown>, opts?: EventOpts): AsyncResult<void, ValidationError | UnexpectedError>;
-        };
-    };
-};
-export type ActiveEventPublishFacade<TA extends AnyTrellisAPI = TrellisAPI> = {
-    readonly [TGroup in SurfaceGroupName<EventsOf<TA>>]: {
-        readonly [E in SurfaceKeysForGroup<EventsOf<TA>, TGroup> as SurfaceLeafName<E>]: {
-            prepare(event: EventPayloadOf<TA, E>): Result<PreparedTrellisEvent<EventPayloadOf<TA, E>>, ValidationError | UnexpectedError>;
-            publish(event: EventPayloadOf<TA, E>): AsyncResult<void, ValidationError | UnexpectedError>;
-        };
-    };
-};
-export type ActiveFeedFacade<TA extends AnyTrellisAPI = TrellisAPI> = {
-    readonly [TGroup in SurfaceGroupName<FeedsOf<TA>>]: {
-        readonly [F in SurfaceKeysForGroup<FeedsOf<TA>, TGroup> as SurfaceLeafName<F>]: (input: FeedInputOf<TA, F>, opts?: FeedSubscribeOpts) => AsyncResult<FeedSubscription<FeedEventOf<TA, F>>, BaseError>;
-    };
-};
-export type ActiveOperationFacade<TA extends AnyTrellisAPI = TrellisAPI> = {
-    readonly [TGroup in SurfaceGroupName<OperationsOf<TA>>]: {
-        readonly [O in SurfaceKeysForGroup<OperationsOf<TA>, TGroup> as SurfaceLeafName<O>]: OperationInvoker<TA["operations"][O] & RuntimeOperationDesc>;
-    };
-};
-export type ActiveRpcHandleFacade<TA extends AnyTrellisAPI = TrellisAPI, TRequests = RpcRequestShapes<TA>> = {
-    readonly [TGroup in SurfaceGroupName<MethodsOf<TA>>]: {
-        readonly [M in SurfaceKeysForGroup<MethodsOf<TA>, TGroup> as SurfaceLeafName<M>]: (handler: HandlerFn<TA, M, TA, HandlerTrellis<TA, TRequests>>) => Promise<void>;
-    };
-};
-export type FeedSurface<TA extends AnyTrellisAPI, TMode extends TrellisMode, F extends FeedsOf<TA>> = TMode extends "server" ? FeedRegistration<FeedInputOf<TA, F>, FeedEventOf<TA, F>> : FeedInputBuilder<FeedInputOf<TA, F>, FeedEventOf<TA, F>>;
-type MaybePromise<T> = T | Promise<T>;
-type EventCallback<TMessage> = {
-    bivarianceHack(message: TMessage): MaybeAsync<void, BaseError>;
-}["bivarianceHack"];
-export type RpcHandlerContext = {
-    caller: SessionCaller;
-    sessionKey: string;
-};
-export type HandlerTrellis<TA extends AnyTrellisAPI, TRequests = RpcRequestShapes<TA>> = {
-    readonly rpc: ActiveRpcFacade<TA>;
-    readonly event: ActiveEventPublishFacade<TA>;
-    readonly feed: ActiveFeedFacade<TA>;
-    readonly operation: ActiveOperationFacade<TA>;
-    request<const M extends RequestMethodOf<TRequests>>(method: M, input: RequestInputOf<TRequests, M>, opts?: RequestOpts): AsyncResult<RequestOutputOf<TRequests, M>, BaseError>;
-    publish(event: string, data: Record<string, unknown>): AsyncResult<void, ValidationError | UnexpectedError>;
-    prepare(event: string, data: Record<string, unknown>): Result<PreparedTrellisEvent, ValidationError | UnexpectedError>;
-    publishPrepared(event: PreparedTrellisEvent): AsyncResult<void, UnexpectedError>;
-};
-export type HandlerKvFacade<TKv extends ContractKvMetadata> = {
-    [K in keyof TKv]: TKv[K]["required"] extends false ? TypedKV<TKv[K]["schema"]> | undefined : TypedKV<TKv[K]["schema"]>;
-};
-export type HandlerStoreHandle = {
-    open(): AsyncResult<TypedStore, StoreError>;
-    waitFor(key: string, options?: StoreWaitOptions): AsyncResult<TypedStoreEntry, StoreError>;
-};
-export type HandlerJobQueue<TPayload, TResult, TTrellis> = {
-    create(payload: TPayload): AsyncResult<JobRef<TPayload, TResult>, BaseError>;
-    handle(handler: (args: {
-        job: ActiveJob<TPayload, TResult>;
-        client: TTrellis;
-    }) => Promise<Result<TResult, BaseError>>): void;
-};
-export type HandlerJobsFacade<TJobs extends Record<string, JobTypeMetadata>, TTrellis> = {
-    [K in keyof TJobs]: HandlerJobQueue<TJobs[K]["payload"], TJobs[K]["result"], TTrellis>;
-};
-export type HandlerTrellisForContract<TContract> = HandlerTrellis<TrellisApiFor<TContract>> & {
-    kv: HandlerKvFacade<ContractKvFor<TContract>>;
-    store: Record<string, HandlerStoreHandle>;
-    jobs: HandlerJobsFacade<ContractJobsFor<TContract>, HandlerTrellisForContract<TContract>>;
-};
-/** Public client-side surface returned by `TrellisClient.connect`. */
-export type ClientTrellis<TA extends AnyTrellisAPI = TrellisAPI, TState extends RuntimeStateStores = {}, TRequests = RpcRequestShapes<TA>> = {
-    readonly name: string;
-    readonly timeout: number;
-    readonly stream: string;
-    readonly api: TA;
-    readonly state: StateFacade<TState>;
-    readonly connection: TrellisConnection;
-    readonly natsConnection: NatsConnection;
-    readonly rpc: ActiveRpcFacade<TA>;
-    readonly event: ActiveEventFacade<TA>;
-    readonly feed: ActiveFeedFacade<TA>;
-    readonly operation: ActiveOperationFacade<TA>;
-    readonly handle: {
-        readonly rpc: ActiveRpcHandleFacade<TA, TRequests>;
-    };
-    request<const M extends RequestMethodOf<TRequests>>(method: M, input: RequestInputOf<TRequests, M>, opts?: RequestOpts): AsyncResult<RequestOutputOf<TRequests, M>, BaseError>;
-    publish<E extends EventsOf<TA>>(event: E, data: EventPayloadOf<TA, E>): AsyncResult<void, ValidationError | UnexpectedError>;
-    prepare<E extends EventsOf<TA>>(event: E, data: EventPayloadOf<TA, E>): Result<PreparedTrellisEvent<EventPayloadOf<TA, E>>, ValidationError | UnexpectedError>;
-    publishPrepared(event: PreparedTrellisEvent): AsyncResult<void, UnexpectedError>;
-    transfer(grant: SendTransferGrant): SendTransferHandle;
-    transfer(grant: ReceiveTransferGrant): ReceiveTransferHandle;
-    wait(): AsyncResult<void, BaseError>;
-};
-/** Connected client type for a generated Trellis contract. */
-export type ConnectedTrellisClient<TContract> = Simplify<ClientTrellis<TContract extends {
-    API: {
-        trellis?: infer TApi;
-    };
-} ? NonNullable<TApi> extends AnyTrellisAPI ? NonNullable<TApi> : TrellisAPI : TrellisAPI, RuntimeStateStoresForContract<TContract>>>;
-export type HandlerArgs<TMountApi extends AnyTrellisAPI, M extends MethodsOf<TMountApi>, TOutboundApi extends AnyTrellisAPI = TMountApi, TTrellis = HandlerTrellis<TOutboundApi>> = {
-    input: MethodInputOf<TMountApi, M>;
-    context: RpcHandlerContext;
-    client: TTrellis;
-};
-export type HandlerFn<TMountApi extends AnyTrellisAPI, M extends MethodsOf<TMountApi>, TOutboundApi extends AnyTrellisAPI = TMountApi, TTrellis = HandlerTrellis<TOutboundApi>> = (args: HandlerArgs<TMountApi, M, TOutboundApi, TTrellis>) => MaybePromise<Result<MethodOutputOf<TMountApi, M>, HandlerErrorOf<TMountApi, M>>>;
-export type RpcHandlerFn<TA extends AnyTrellisAPI, M extends RpcMethodNameOf<TA>> = HandlerFn<TA, M, TA>;
-export type TrellisFor<TContract> = HandlerTrellisForContract<TContract>;
-export type RpcArgs<TContract, M extends RpcMethodNameOf<OwnedApiFor<TContract>>> = HandlerArgs<OwnedApiFor<TContract>, M, TrellisApiFor<TContract>, HandlerTrellisForContract<TContract>>;
-export type RpcResult<TContract, M extends RpcMethodNameOf<OwnedApiFor<TContract>>> = Result<RpcOutputOf<OwnedApiFor<TContract>, M>, RpcHandlerErrorOf<OwnedApiFor<TContract>, M>>;
-export type RpcRequestErrorOf<TA extends AnyTrellisAPI, M extends RpcMethodNameOf<TA>> = RequestErrorOf<TA, M>;
-export type RpcHandlerErrorOf<TA extends AnyTrellisAPI, M extends RpcMethodNameOf<TA>> = HandlerErrorOf<TA, M>;
-export type EventName<TContract> = EventsOf<OwnedApiFor<TContract>>;
-export type EventType<TContract, E extends EventName<TContract>> = EventOf<OwnedApiFor<TContract>, E>;
-export type EventPayload<TContract, E extends EventName<TContract>> = EventPayloadOf<OwnedApiFor<TContract>, E>;
-export type EventHandler<TContract, E extends EventName<TContract>> = (event: EventType<TContract, E>) => MaybeAsync<void, BaseError>;
-export declare class Trellis<TA extends AnyTrellisAPI = TrellisAPI, TMode extends TrellisMode = "client", TState extends RuntimeStateStores = {}, TRequests = RpcRequestShapes<TA>> {
-    #private;
-    readonly name: string;
-    readonly timeout: number;
-    readonly stream: string;
-    readonly state: StateFacade<TState>;
-    readonly rpc: ActiveRpcFacade<TA>;
-    readonly event: ActiveEventFacade<TA>;
-    readonly feed: ActiveFeedFacade<TA>;
-    readonly operation: ActiveOperationFacade<TA>;
-    readonly handle: {
-        readonly rpc: ActiveRpcHandleFacade<TA, TRequests>;
-    };
-    /** Framework-neutral lifecycle handle for this Trellis runtime connection. */
-    readonly connection: TrellisConnection;
-    protected nats: NatsConnection;
-    protected js: JetStreamClient;
-    protected auth: TrellisAuth;
-    readonly api: TA;
-    constructor(name: string, // Must be unique for a service
-    nats: NatsConnection, auth: TrellisAuth, opts?: TrellisOpts<TA>);
-    /**
-     * Returns the underlying NATS connection.
-     */
-    get natsConnection(): NatsConnection;
-    operationStoreHandle(): Promise<TypedKV<typeof DurableOperationRecordSchema>>;
-    loadOperationRecord(operationId: string): Promise<DurableOperationRecord | null>;
-    saveOperationRecord(runtime: RuntimeOperationRecord): Promise<void>;
-    /**
-     * Makes an authenticated request to a Trellis RPC method.
-     *
-     * @template M The specific RPC method being called.
-     * @param method The name of the RPC method to call.
-     * @param input The input data for the method, conforming to its schema.
-     * @param opts Optional request-specific options.
-     * @returns An `AsyncResult` containing either the method's output or an error.
-     * @returns A `Result` object after awaiting:
-     *              ok: A validated response for method M
-     *              err: declared RPC errors | RemoteError | ValidationError | UnexpectedError
-     */
-    request<const M extends RequestMethodOf<TRequests>>(method: M, input: RequestInputOf<TRequests, M>, opts?: RequestOpts): AsyncResult<RequestOutputOf<TRequests, M>, BaseError>;
-    feedHandle<F extends FeedsOf<TA>>(feed: F): FeedInputBuilder<FeedInputOf<TA, F>, FeedEventOf<TA, F>> & FeedRegistration<FeedInputOf<TA, F>, FeedEventOf<TA, F>>;
-    operationHandle<O extends OperationsOf<TA>>(operation: O): OperationSurface<TA, TMode, O>;
-    /**
-     * Creates a helper for a short-lived Trellis transfer grant.
-     */
-    transfer(grant: SendTransferGrant): SendTransferHandle;
-    transfer(grant: ReceiveTransferGrant): ReceiveTransferHandle;
-    mount(method: string, fn: (args: {
-        input: unknown;
-        context: RpcHandlerContext;
-        client: HandlerTrellis<TA, TRequests>;
-    }) => MaybePromise<Result<unknown, BaseError>>): Promise<void>;
-    respondWithError(msg: Msg, error: Error | BaseError): void;
-    /**
-     * Builds a stable event subject, encoded payload, and publish headers.
-     *
-     * The prepared event intentionally carries no contract id or digest so callers
-     * can persist it in a service-owned outbox without coupling storage to the
-     * publisher's current deployment metadata.
-     */
-    prepare(event: string, data: Record<string, unknown>): Result<PreparedTrellisEvent, ValidationError | UnexpectedError>;
-    /**
-     * Publishes a previously prepared event without regenerating its id, time,
-     * subject, payload, or headers.
-     */
-    publishPrepared(event: PreparedTrellisEvent): AsyncResult<void, UnexpectedError>;
-    publish(event: string, data: Record<string, unknown>): AsyncResult<void, ValidationError | UnexpectedError>;
-    listenEvent<E extends EventsOf<TA>>(event: E, subjectData: Record<string, unknown>, fn: EventCallback<EventOf<TA, E>>, opts?: EventOpts): AsyncResult<void, ValidationError | UnexpectedError>;
-    wait(): AsyncResult<void, BaseError>;
-    template(subject: string, data: unknown, allowWildcards?: boolean): Result<string, ValidationError>;
-    protected requestAuthValidate(input: AuthRequestsValidateInput): AsyncResult<AuthRequestsValidateResponse, AuthError | RemoteError | TransportError | ValidationError | UnexpectedError>;
-}
-//# sourceMappingURL=trellis.d.ts.map