service-bridge 1.8.5-dev.49 → 2.0.0-alpha

package/dist/service-bridge-CPmirNES.d.ts

@@ -0,0 +1,2261 @@
+import * as grpc from '@grpc/grpc-js';
+import { Client, CallOptions, ClientReadableStream, Metadata, ChannelCredentials, ClientOptions, ServiceError, ClientUnaryCall, ClientDuplexStream } from '@grpc/grpc-js';
+import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
+
+/**
+ * Route — canonical HTTP route entry collected by an integration (Express /
+ * Fastify / Hono) and published into the SB registry as METHOD_TYPE_HTTP.
+ *
+ * @internal — потребляется только интеграциями `servicebridge/{express,
+ * fastify,hono}` через `ServiceBridge.routes`. Прикладной код использует
+ * subpath-API, см. ../../userDocs/integrations.md.
+ */
+interface Route {
+    /** Uppercase HTTP method: "GET", "POST", "PUT", "PATCH", "DELETE", etc. */
+    method: string;
+    /** Raw framework pattern. SDK не нормализует — косметика на UI Service Map. */
+    pattern: string;
+    /** Source framework, for diagnostics and (later) Service Map UI badges. */
+    source: "express" | "fastify" | "hono";
+}
+/**
+ * Хук, передаваемый коллектору при конструировании. Реализуется `ServiceBridge`:
+ * `setEndpoint` синхронно обновляет `Registry._httpEndpoint`; `triggerRestart`
+ * рестартует Registry-watch стрим, если SDK уже запущен (no-op до `start()`).
+ *
+ * @internal
+ */
+interface RouteSink {
+    setEndpoint(endpoint: string): void;
+    triggerRestart(): void;
+}
+/**
+ * RouteCollector аккумулирует роуты по ключу `${method} ${pattern}` (дедуп) и
+ * управляет HTTP-endpoint жизненным циклом инстанса.
+ *
+ * Один публичный метод `publishHttp({host, port})`:
+ *   1. Записывает endpoint в Registry (`sink.setEndpoint`).
+ *   2. Триггерит `sink.triggerRestart()` — рестарт Registry-watch стрима.
+ *      Если SDK ещё не стартовал, `triggerRestart` — no-op; endpoint просто
+ *      оседает и попадёт в первый `RegisterRequest`.
+ *
+ * @internal
+ */
+declare class RouteCollector {
+    private readonly _routes;
+    private readonly _sink;
+    constructor(sink: RouteSink);
+    /** Добавляет роут. Дедуп по `${method} ${pattern}`. */
+    add(route: Route): void;
+    /** Сколько роутов уже собрано (для диагностики тестов). */
+    size(): number;
+    /**
+     * Записывает endpoint в Registry и триггерит `triggerRestart` callback.
+     * Безопасен до `sb.start()` — `triggerRestart` тогда no-op.
+     */
+    publishHttp(endpoint: {
+        host: string;
+        port: number;
+    }): void;
+    /** Snapshot собранных роутов в порядке добавления (insertion order Map). */
+    snapshot(): readonly Route[];
+}
+
+declare enum MethodType {
+    METHOD_TYPE_UNSPECIFIED = 0,
+    METHOD_TYPE_RPC = 1,
+    METHOD_TYPE_EVENT = 2,
+    METHOD_TYPE_WORKFLOW = 3,
+    METHOD_TYPE_JOB = 4,
+    METHOD_TYPE_HTTP = 5,
+    UNRECOGNIZED = -1
+}
+/**
+ * CaptureMode is one channel's payload capture policy. The runtime is the
+ * single authority: it resolves each channel's mode from runtime settings and
+ * pushes the whole CaptureModes set to every SDK over RegisterAndWatch. SDKs
+ * apply the mode for an op's channel as its effective capture mode; a per-handler
+ * override may only narrow it (privacy ordering NONE < ERRORS < ALL), never
+ * widen it.
+ */
+declare enum CaptureMode$1 {
+    CAPTURE_MODE_UNSPECIFIED = 0,
+    CAPTURE_MODE_ALL = 1,
+    CAPTURE_MODE_ERRORS = 2,
+    CAPTURE_MODE_NONE = 3,
+    UNRECOGNIZED = -1
+}
+/**
+ * CaptureModes carries the per-channel payload capture policy pushed to SDKs.
+ * One CaptureMode per op channel; the runtime resolves each from its matching
+ * <channel>.payload_capture setting. The SDK picks the mode for an op's channel.
+ * Jobs carry no input/output payload (JobExecution has no args, the handler
+ * returns void), so the job channel has no capture mode — field 5 is reserved.
+ */
+interface CaptureModes {
+    rpc: CaptureMode$1;
+    http: CaptureMode$1;
+    event: CaptureMode$1;
+    workflow: CaptureMode$1;
+}
+declare const CaptureModes: MessageFns$5<CaptureModes>;
+interface IncomingMethod {
+    type: MethodType;
+    name: string;
+    inputSchemaJson: Buffer;
+    outputSchemaJson: Buffer;
+    streaming: boolean;
+    /**
+     * SDK-supplied contract hash (hex SHA-256). Runtime stores opaque,
+     * does not recompute. Empty for non-RPC method types (event/workflow/job/http).
+     */
+    contractHash: string;
+}
+declare const IncomingMethod: MessageFns$5<IncomingMethod>;
+interface PublishedEvent {
+    name: string;
+    schemaJson: Buffer;
+    /**
+     * SDK-supplied contract hash (hex SHA-256) of the Protobuf descriptor for
+     * this event's payload schema. Empty when the publisher declared the event
+     * without a schema. Runtime stores opaque, does not recompute (ADR-0005).
+     */
+    contractHash: string;
+}
+declare const PublishedEvent: MessageFns$5<PublishedEvent>;
+interface OutgoingDep {
+    serviceName: string;
+    methodName: string;
+    type: MethodType;
+}
+declare const OutgoingDep: MessageFns$5<OutgoingDep>;
+interface EventSubscription {
+    pattern: string;
+    durable: boolean;
+}
+declare const EventSubscription: MessageFns$5<EventSubscription>;
+interface RegisterRequest {
+    incoming: IncomingMethod[];
+    published: PublishedEvent[];
+    outgoing: OutgoingDep[];
+    callEndpoint: string;
+    eventSubscriptions: EventSubscription[];
+    /**
+     * Public HTTP host:port of this SDK instance (ADR 0001 — HTTP lives in user
+     * app). Used only by Service Map / Discovery; runtime does not proxy HTTP.
+     * Empty when SDK has no HTTP integration registered.
+     */
+    httpEndpoint: string;
+}
+declare const RegisterRequest: MessageFns$5<RegisterRequest>;
+interface MethodDescriptor {
+    serviceName: string;
+    serviceId: string;
+    instanceId: string;
+    type: MethodType;
+    name: string;
+    contractHash: string;
+    published: boolean;
+    inputSchema: Buffer;
+    outputSchema: Buffer;
+    streaming: boolean;
+}
+declare const MethodDescriptor: MessageFns$5<MethodDescriptor>;
+interface ServiceInstanceInfo {
+    instanceId: string;
+    serviceId: string;
+    serviceName: string;
+    callEndpoint: string;
+    status: string;
+    /**
+     * Public HTTP host:port of this instance (ADR 0001). Empty when instance has
+     * no HTTP integration or after disconnect.
+     */
+    httpEndpoint: string;
+    /**
+     * Start of the current unhealthy window for this instance (ADR-0008 §6).
+     * Unix-ms timestamp; 0 when the instance is healthy. SDK-side LB treats it as a hint.
+     */
+    isUnhealthySinceUnixMs: number;
+}
+declare const ServiceInstanceInfo: MessageFns$5<ServiceInstanceInfo>;
+interface RegistrySnapshot {
+    methods: MethodDescriptor[];
+    instances: ServiceInstanceInfo[];
+    /**
+     * ── Service-map enrichment (ADR-0014) ────────────────────────────────────
+     * Per-service event subscriptions visible to the caller. Combined with
+     * event publishers from `methods` (METHOD_TYPE_EVENT + published=true) this
+     * lets UI / SDK draw the full pub/sub graph including wildcards.
+     */
+    eventSubscriptions: EventSubscriptionDescriptor[];
+    /**
+     * Per-service outgoing call declarations from sb.service(...). One row per
+     * (caller_service, target_service, target_method, target_type) tuple.
+     */
+    outgoingCalls: OutgoingCallDescriptor[];
+    /**
+     * Policy evaluation for the caller of this RegisterAndWatch stream — the
+     * caller's effective capabilities + rules + per-declaration warnings.
+     */
+    policy?: PolicyEvaluation | undefined;
+    /**
+     * Per-channel payload capture modes. Always stamped on the snapshot so the
+     * SDK has an effective mode per channel from the first frame (before any
+     * update).
+     */
+    captureModes?: CaptureModes | undefined;
+}
+declare const RegistrySnapshot: MessageFns$5<RegistrySnapshot>;
+interface RegistryUpdate {
+    added: MethodDescriptor[];
+    removed: MethodDescriptor[];
+    addedInstances: ServiceInstanceInfo[];
+    removedInstances: ServiceInstanceInfo[];
+    /** Same enrichment as RegistrySnapshot.* but incremental. */
+    addedEventSubscriptions: EventSubscriptionDescriptor[];
+    removedEventSubscriptions: EventSubscriptionDescriptor[];
+    addedOutgoingCalls: OutgoingCallDescriptor[];
+    removedOutgoingCalls: OutgoingCallDescriptor[];
+    /**
+     * When policy changes (NOTIFY policy_changed touches caller), runtime
+     * re-emits the full PolicyEvaluation. Not incremental on purpose: policy
+     * edits are rare and the evaluation is small.
+     */
+    policy?: PolicyEvaluation | undefined;
+    /**
+     * Derived from per-field diff after a policy push. peer_id is in
+     * added_peers when it first appears in the caller's scope; in removed_peers
+     * when the last method/instance/subscription from that peer disappears from
+     * scope. SDK uses these to update serviceMap and close stale direct-conns.
+     */
+    addedPeers: string[];
+    removedPeers: string[];
+    /**
+     * Re-emitted full per-channel capture modes when any channel's mode changes.
+     * Like policy, not incremental: the whole set is sent on change.
+     */
+    captureModes?: CaptureModes | undefined;
+}
+declare const RegistryUpdate: MessageFns$5<RegistryUpdate>;
+interface RegistryEvent {
+    snapshot?: RegistrySnapshot | undefined;
+    update?: RegistryUpdate | undefined;
+}
+declare const RegistryEvent: MessageFns$5<RegistryEvent>;
+interface EventSubscriptionDescriptor {
+    serviceId: string;
+    serviceName: string;
+    /** AMQP pattern, supports * and # */
+    pattern: string;
+    durable: boolean;
+}
+declare const EventSubscriptionDescriptor: MessageFns$5<EventSubscriptionDescriptor>;
+interface OutgoingCallDescriptor {
+    callerServiceId: string;
+    callerServiceName: string;
+    targetServiceId: string;
+    targetServiceName: string;
+    targetMethod: string;
+    /** RPC, WORKFLOW, HTTP */
+    targetType: MethodType;
+}
+declare const OutgoingCallDescriptor: MessageFns$5<OutgoingCallDescriptor>;
+interface PolicyEvaluation {
+    /**
+     * Capability flags currently enabled for the caller — names of the four
+     * booleans on services that are TRUE: "rpc.handle", "event.handle",
+     * "workflow.handle", "job.handle".
+     */
+    capabilities: string[];
+    /** The caller's effective egress rules. */
+    egress: PolicyRule[];
+    /** The caller's effective acceptance rules. */
+    acceptance: PolicyRule[];
+    /** Per-declaration violations from the most recent registration. */
+    warnings: PolicyViolation[];
+}
+declare const PolicyEvaluation: MessageFns$5<PolicyEvaluation>;
+interface PolicyRule {
+    /**
+     * 'rpc.call' | 'workflow.run' | 'event.publish' for egress;
+     * 'rpc.handle' | 'workflow.handle' | 'event.handle' for acceptance.
+     */
+    action: string;
+    /**
+     * For rpc.* /workflow.*: peer service UUID (target for egress, caller for
+     * acceptance). Empty string for event.* (no per-service routing).
+     */
+    peerServiceId: string;
+    /** Human-readable peer service name (for UI / sb-policy show). */
+    peerServiceName: string;
+    /**
+     * Method name pattern (literal or '*') for rpc.* /workflow.*; AMQP pattern
+     * for event.*.
+     */
+    targetName: string;
+}
+declare const PolicyRule: MessageFns$5<PolicyRule>;
+interface PolicyViolation {
+    /**
+     * Declaration type, e.g. 'rpc.call', 'event.handle', 'event.publish',
+     * 'rpc.handle' (capability), etc.
+     */
+    declaration: string;
+    /** Concrete value, e.g. 'payments/charge', 'orders.*'. */
+    value: string;
+    /** 'capability' | 'self_egress' | 'self_acceptance' | 'peer_acceptance'. */
+    denySide: string;
+    /** Human-readable explanation. */
+    reason: string;
+}
+declare const PolicyViolation: MessageFns$5<PolicyViolation>;
+type RegistryService = typeof RegistryService;
+declare const RegistryService: {
+    readonly registerAndWatch: {
+        readonly path: "/servicebridge.v1.Registry/RegisterAndWatch";
+        readonly requestStream: false;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: RegisterRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => RegisterRequest;
+        readonly responseSerialize: (value: RegistryEvent) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => RegistryEvent;
+    };
+};
+interface RegistryClient extends Client {
+    registerAndWatch(request: RegisterRequest, options?: Partial<CallOptions>): ClientReadableStream<RegistryEvent>;
+    registerAndWatch(request: RegisterRequest, metadata?: Metadata, options?: Partial<CallOptions>): ClientReadableStream<RegistryEvent>;
+}
+declare const RegistryClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): RegistryClient;
+    service: typeof RegistryService;
+    serviceName: string;
+};
+type Builtin$5 = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$5<T> = T extends Builtin$5 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$5<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$5<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$5<T[K]>;
+} : Partial<T>;
+type KeysOfUnion$5<T> = T extends T ? keyof T : never;
+type Exact$5<P, I extends P> = P extends Builtin$5 ? P : P & {
+    [K in keyof P]: Exact$5<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion$5<P>>]: never;
+};
+interface MessageFns$5<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    create<I extends Exact$5<DeepPartial$5<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact$5<DeepPartial$5<T>, I>>(object: I): T;
+}
+
+type CaptureMode = "all" | "errors" | "none";
+
+interface DispatchPort {
+    dispatchUnary(method: string, payload: Uint8Array): Promise<UnaryResult>;
+    dispatchStream(method: string, payload: Uint8Array): AsyncIterable<StreamItem>;
+    captureMode(method: string): CaptureMode | undefined;
+}
+interface UnaryResult {
+    payload: Uint8Array;
+    errorCode?: string;
+    errorMessage?: string;
+}
+interface StreamItem {
+    payload?: Uint8Array;
+    errorCode?: string;
+    errorMessage?: string;
+}
+
+interface JsonSchemaFileSpec {
+    schemaFile: string;
+}
+
+interface ProtoFileSpec {
+    protoFile: string;
+    input?: string;
+    output?: string;
+    method?: string;
+}
+type SchemaSpec = ProtoFileSpec | JsonSchemaFileSpec;
+interface Serializer {
+    encode(value: unknown): Uint8Array;
+    decode(bytes: Uint8Array): unknown;
+    contractHash(): string;
+    toJsonSchema(): Record<string, unknown>;
+}
+interface SchemaPair {
+    input: Serializer;
+    output: Serializer;
+}
+
+interface RpcHandlerOpts {
+    schema: SchemaSpec;
+    captureMode?: CaptureMode;
+}
+interface WorkflowHandlerOpts {
+    input?: Record<string, unknown>;
+}
+interface ServiceDeps {
+    rpc?: string[];
+    workflows?: string[];
+    http?: string[];
+}
+type RpcHandlerFn<Req = unknown, Res = unknown> = (req: Req) => Promise<Res> | Res;
+type RpcStreamHandlerFn<Req = unknown, Chunk = unknown> = (req: Req) => AsyncIterable<Chunk>;
+interface HandlerEntry {
+    type: MethodType;
+    name: string;
+    inputSchemaJson: Buffer | null;
+    outputSchemaJson: Buffer | null;
+    fn: unknown;
+    streaming?: boolean;
+    schemaPair?: SchemaPair;
+    contractHashOverride?: string;
+    captureMode?: CaptureMode;
+}
+interface PublishedEntry {
+    name: string;
+    inputSchemaJson: Buffer | null;
+    contractHash: string;
+    schemaPair?: SchemaPair;
+    spec?: SchemaSpec;
+}
+declare class Handle {
+    readonly _entries: HandlerEntry[];
+    readonly _published: PublishedEntry[];
+    private pending;
+    rpc<Req = unknown, Res = unknown>(name: string, fn: RpcHandlerFn<Req, Res>, opts: RpcHandlerOpts): void;
+    stream<Req = unknown, Chunk = unknown>(name: string, fn: RpcStreamHandlerFn<Req, Chunk>, opts: RpcHandlerOpts): void;
+    _declareForTests(name: string, streaming?: boolean): void;
+    private registerRpc;
+    publishEvent(name: string, spec?: SchemaSpec): void;
+    getPublishedEvent(name: string): {
+        contractHash: string;
+        pair: SchemaPair;
+    } | undefined;
+    _declarePublishedEventForTests(name: string): void;
+    event(name: string, fn: unknown): void;
+    workflow(name: string, steps: unknown, opts?: WorkflowHandlerOpts, graphJson?: Buffer, contractHash?: string): void;
+    job(name: string, contractHash: string, specJson: string, fn: unknown): void;
+    finalize(): Promise<void>;
+    incomingMethods(): IncomingMethod[];
+    publishedEvents(): PublishedEvent[];
+    asDispatchPort(): DispatchPort;
+}
+declare class Registry {
+    readonly _handle: Handle;
+    /**
+     * Public-but-undocumented route collector. Используется только интеграциями
+     * `servicebridge/{express,fastify,hono}`. Прикладной код пишет роуты в свой
+     * фреймворк, не сюда. См. ADR 0001 и userDocs/integrations.md.
+     */
+    readonly routes: RouteCollector;
+    private readonly _outgoing;
+    /**
+     * @param onRestart — вызывается из `routes.publishHttp(...)` после записи
+     * нового endpoint'а. ServiceBridge подставляет туда рестарт Registry-watch
+     * стрима. До `sb.start()` callback ожидает no-op.
+     */
+    constructor(onRestart?: () => void);
+    service(serviceName: string, deps: ServiceDeps): void;
+    buildRegisterRequest(): RegisterRequest;
+    setCallEndpoint(endpoint: string): void;
+    private _callEndpoint;
+    private _httpEndpoint;
+}
+
+declare enum PublishStatus {
+    PUBLISH_STATUS_UNSPECIFIED = 0,
+    PUBLISH_STATUS_ACCEPTED = 1,
+    PUBLISH_STATUS_REJECTED_DUPLICATE = 3,
+    PUBLISH_STATUS_REJECTED_INVALID_NAME = 5,
+    /**
+     * PUBLISH_STATUS_REJECTED_FORBIDDEN - ADR-0014: publisher does not have event.publish action rule matching this
+     * event name (or its capability is disabled). Per-envelope reject — other
+     * events in the batch proceed.
+     */
+    PUBLISH_STATUS_REJECTED_FORBIDDEN = 6,
+    UNRECOGNIZED = -1
+}
+interface EventEnvelope {
+    id: string;
+    name: string;
+    payload: Buffer;
+    contractHash: string;
+    partitionKey: string;
+    idempotencyKey: string;
+    fireAndForget: boolean;
+    headers: {
+        [key: string]: string;
+    };
+    occurredAtUnixMs: number;
+    /** X-SB-Trace propagation: carried in EventEnvelope for publisher→consumer. */
+    xSbTrace: string;
+    /**
+     * payload_json — JSON-encoded view of the same payload, populated by the
+     * publisher SDK alongside the canonical protobuf `payload`. Used by the
+     * workflow signal router to evaluate JSON-path `wait_event` filters
+     * without decoding the protobuf form (runtime treats payload as opaque
+     * bytes per ADR-0013). Empty when publisher cannot produce JSON.
+     */
+    payloadJson: Buffer;
+}
+declare const EventEnvelope: MessageFns$4<EventEnvelope>;
+interface PublishRequest {
+    publisherServiceId: string;
+    publisherInstanceId: string;
+    events: EventEnvelope[];
+}
+declare const PublishRequest: MessageFns$4<PublishRequest>;
+interface PublishStatusEntry {
+    eventId: string;
+    status: PublishStatus;
+    message: string;
+}
+declare const PublishStatusEntry: MessageFns$4<PublishStatusEntry>;
+interface PublishResponse {
+    results: PublishStatusEntry[];
+}
+declare const PublishResponse: MessageFns$4<PublishResponse>;
+interface SubscribeInit {
+    subscriberServiceId: string;
+    subscriberInstanceId: string;
+    maxInFlight: number;
+}
+declare const SubscribeInit: MessageFns$4<SubscribeInit>;
+interface Ack {
+    deliveryId: string;
+    eventId: Buffer;
+}
+declare const Ack: MessageFns$4<Ack>;
+interface Nack {
+    deliveryId: string;
+    errorMessage: string;
+    eventId: Buffer;
+}
+declare const Nack: MessageFns$4<Nack>;
+interface SubscribeClientMessage {
+    init?: SubscribeInit | undefined;
+    ack?: Ack | undefined;
+    nack?: Nack | undefined;
+}
+declare const SubscribeClientMessage: MessageFns$4<SubscribeClientMessage>;
+interface EventDelivery {
+    deliveryId: string;
+    envelope?: EventEnvelope | undefined;
+    attempt: number;
+}
+declare const EventDelivery: MessageFns$4<EventDelivery>;
+interface SubscribeServerMessage {
+    delivery?: EventDelivery | undefined;
+}
+declare const SubscribeServerMessage: MessageFns$4<SubscribeServerMessage>;
+interface ReplayDlqRequest {
+    eventId: string;
+}
+declare const ReplayDlqRequest: MessageFns$4<ReplayDlqRequest>;
+interface ReplayDlqResponse {
+    eventId: string;
+}
+declare const ReplayDlqResponse: MessageFns$4<ReplayDlqResponse>;
+interface ListDlqRequest {
+    limit: number;
+    cursor: string;
+}
+declare const ListDlqRequest: MessageFns$4<ListDlqRequest>;
+interface DlqEntry {
+    eventId: string;
+    eventName: string;
+    consumerService: string;
+    lastError: string;
+    dlqAtUnixMs: number;
+    replayCount: number;
+    totalAttempts: number;
+}
+declare const DlqEntry: MessageFns$4<DlqEntry>;
+interface ListDlqResponse {
+    entries: DlqEntry[];
+    nextCursor: string;
+}
+declare const ListDlqResponse: MessageFns$4<ListDlqResponse>;
+type EventsService = typeof EventsService;
+declare const EventsService: {
+    readonly publish: {
+        readonly path: "/servicebridge.v1.Events/Publish";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: PublishRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => PublishRequest;
+        readonly responseSerialize: (value: PublishResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => PublishResponse;
+    };
+    readonly subscribe: {
+        readonly path: "/servicebridge.v1.Events/Subscribe";
+        readonly requestStream: true;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: SubscribeClientMessage) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => SubscribeClientMessage;
+        readonly responseSerialize: (value: SubscribeServerMessage) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => SubscribeServerMessage;
+    };
+    readonly replayDlq: {
+        readonly path: "/servicebridge.v1.Events/ReplayDlq";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ReplayDlqRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ReplayDlqRequest;
+        readonly responseSerialize: (value: ReplayDlqResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ReplayDlqResponse;
+    };
+    readonly listDlq: {
+        readonly path: "/servicebridge.v1.Events/ListDlq";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ListDlqRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ListDlqRequest;
+        readonly responseSerialize: (value: ListDlqResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ListDlqResponse;
+    };
+};
+interface EventsClient extends Client {
+    publish(request: PublishRequest, callback: (error: ServiceError | null, response: PublishResponse) => void): ClientUnaryCall;
+    publish(request: PublishRequest, metadata: Metadata, callback: (error: ServiceError | null, response: PublishResponse) => void): ClientUnaryCall;
+    publish(request: PublishRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: PublishResponse) => void): ClientUnaryCall;
+    subscribe(): ClientDuplexStream<SubscribeClientMessage, SubscribeServerMessage>;
+    subscribe(options: Partial<CallOptions>): ClientDuplexStream<SubscribeClientMessage, SubscribeServerMessage>;
+    subscribe(metadata: Metadata, options?: Partial<CallOptions>): ClientDuplexStream<SubscribeClientMessage, SubscribeServerMessage>;
+    replayDlq(request: ReplayDlqRequest, callback: (error: ServiceError | null, response: ReplayDlqResponse) => void): ClientUnaryCall;
+    replayDlq(request: ReplayDlqRequest, metadata: Metadata, callback: (error: ServiceError | null, response: ReplayDlqResponse) => void): ClientUnaryCall;
+    replayDlq(request: ReplayDlqRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: ReplayDlqResponse) => void): ClientUnaryCall;
+    listDlq(request: ListDlqRequest, callback: (error: ServiceError | null, response: ListDlqResponse) => void): ClientUnaryCall;
+    listDlq(request: ListDlqRequest, metadata: Metadata, callback: (error: ServiceError | null, response: ListDlqResponse) => void): ClientUnaryCall;
+    listDlq(request: ListDlqRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: ListDlqResponse) => void): ClientUnaryCall;
+}
+declare const EventsClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): EventsClient;
+    service: typeof EventsService;
+    serviceName: string;
+};
+type Builtin$4 = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$4<T> = T extends Builtin$4 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$4<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$4<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$4<T[K]>;
+} : Partial<T>;
+type KeysOfUnion$4<T> = T extends T ? keyof T : never;
+type Exact$4<P, I extends P> = P extends Builtin$4 ? P : P & {
+    [K in keyof P]: Exact$4<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion$4<P>>]: never;
+};
+interface MessageFns$4<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    create<I extends Exact$4<DeepPartial$4<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact$4<DeepPartial$4<T>, I>>(object: I): T;
+}
+
+interface StorageOpenOpts {
+    dataDir?: string;
+}
+interface SqliteStatement {
+    run(...params: unknown[]): unknown;
+    get(...params: unknown[]): unknown;
+    all(...params: unknown[]): unknown[];
+}
+declare class Storage {
+    private readonly db;
+    private constructor();
+    static open(opts?: StorageOpenOpts): Storage;
+    transaction<T>(fn: () => T): T;
+    prepare(sql: string): SqliteStatement;
+    close(): void;
+}
+
+interface PublishOpts {
+    idempotencyKey?: string;
+    partitionKey?: string;
+    fireAndForget?: boolean;
+    headers?: Record<string, string>;
+    occurredAtMs?: number;
+}
+interface SchemaIndex {
+    get(name: string): {
+        contractHash: string;
+        pair: SchemaPair;
+    } | undefined;
+}
+interface DrainerHandle {
+    kick(): void;
+}
+interface Logger {
+    warn(msg: string, ...args: unknown[]): void;
+    error(msg: string, ...args: unknown[]): void;
+}
+interface PublisherDeps {
+    storage: Storage;
+    rpcClient: EventsClient;
+    schemaIndex: SchemaIndex;
+    drainer: DrainerHandle;
+    identity: () => Identity | null;
+    maxOutboxRows: number;
+    logger: Logger;
+    sb?: ServiceBridge;
+    xSbTraceFn: () => string;
+}
+declare class Publisher {
+    private readonly deps;
+    private readonly xSbTraceFn;
+    constructor(deps: PublisherDeps);
+    publish(name: string, payload: unknown, opts?: PublishOpts): Promise<{
+        eventId: string;
+    }>;
+}
+
+declare class EventDomain {
+    private readonly registry;
+    private readonly getPublisher;
+    constructor(registry: Registry, getPublisher: () => Publisher | null);
+    define(name: string, spec?: SchemaSpec): void;
+    handle(pattern: string, fn: (payload: unknown) => Promise<void> | void): void;
+    publish<T = unknown>(name: string, payload: T, opts?: PublishOpts): Promise<{
+        eventId: string;
+    }>;
+}
+
+type CronTrigger = {
+    cron: string;
+    tz?: string;
+};
+type DelayedTrigger = {
+    delayed: {
+        at: Date | string | number;
+    };
+};
+type IntervalTrigger = {
+    interval: number;
+};
+type Trigger = CronTrigger | DelayedTrigger | IntervalTrigger;
+type CatchupPolicy = "skip" | "fire_once" | "fire_all";
+type OverlapPolicy = "skip" | "allow" | "buffer_one";
+type DeclaredDep = {
+    rpc: string;
+} | {
+    event: string;
+} | {
+    workflow: string;
+};
+interface JobHandlerCtx {
+    jobName: string;
+    executionId: string;
+    scheduledAt: Date;
+    localScheduledAt: Date;
+    attempt: number;
+    idempotencyKey: string;
+    signal: AbortSignal;
+}
+type JobHandler = (ctx: JobHandlerCtx) => Promise<void>;
+interface RetryPolicy {
+    initialMs: number;
+    maxMs: number;
+    multiplier: number;
+    jitter: number;
+}
+interface JobOpts {
+    trigger: Trigger;
+    catchup?: CatchupPolicy;
+    overlap?: OverlapPolicy;
+    deps?: DeclaredDep[];
+    maxAttempts?: number;
+    leaseTtlMs?: number;
+    maxConcurrent?: number;
+    retry?: RetryPolicy;
+}
+
+declare class JobDomain {
+    private readonly registry;
+    private readonly _byName;
+    constructor(registry: Registry);
+    handle(name: string, opts: JobOpts, fn: JobHandler): void;
+    /** @internal — used by JobSubscriber to dispatch incoming executions. */
+    lookup(name: string): {
+        opts: JobOpts;
+        fn: JobHandler;
+    } | undefined;
+    /** @internal — used by ServiceBridge to skip subscriber startup when empty. */
+    size(): number;
+}
+
+interface OpenRequest {
+}
+declare const OpenRequest: MessageFns$3<OpenRequest>;
+interface RefreshCertRequest {
+    csrDer: Buffer;
+}
+declare const RefreshCertRequest: MessageFns$3<RefreshCertRequest>;
+interface RefreshCertResponse {
+    certDer: Buffer;
+    caChainDer: Buffer;
+    notAfterUnix: number;
+    instanceId: string;
+}
+declare const RefreshCertResponse: MessageFns$3<RefreshCertResponse>;
+interface ServerControl {
+    welcome?: Welcome | undefined;
+    drain?: Drain | undefined;
+}
+declare const ServerControl: MessageFns$3<ServerControl>;
+interface Welcome {
+    sessionId: string;
+    serviceId: string;
+    serviceName: string;
+}
+declare const Welcome: MessageFns$3<Welcome>;
+interface Drain {
+    reason: string;
+}
+declare const Drain: MessageFns$3<Drain>;
+/**
+ * Control plane stream. After Telemetry feature heartbeat moved out — Control
+ * несёт только server-driven signalling: Welcome (один раз) и Drain (при
+ * shutdown). Cert refresh — отдельным unary RPC.
+ */
+type ControlService = typeof ControlService;
+declare const ControlService: {
+    readonly open: {
+        readonly path: "/servicebridge.v1.Control/Open";
+        readonly requestStream: false;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: OpenRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => OpenRequest;
+        readonly responseSerialize: (value: ServerControl) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ServerControl;
+    };
+    /**
+     * RefreshCert reissues the caller's leaf cert via the existing mTLS
+     * session (SPIFFE from cert == source of truth, no argon2).
+     */
+    readonly refreshCert: {
+        readonly path: "/servicebridge.v1.Control/RefreshCert";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: RefreshCertRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => RefreshCertRequest;
+        readonly responseSerialize: (value: RefreshCertResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => RefreshCertResponse;
+    };
+};
+interface ControlClient extends Client {
+    open(request: OpenRequest, options?: Partial<CallOptions>): ClientReadableStream<ServerControl>;
+    open(request: OpenRequest, metadata?: Metadata, options?: Partial<CallOptions>): ClientReadableStream<ServerControl>;
+    /**
+     * RefreshCert reissues the caller's leaf cert via the existing mTLS
+     * session (SPIFFE from cert == source of truth, no argon2).
+     */
+    refreshCert(request: RefreshCertRequest, callback: (error: ServiceError | null, response: RefreshCertResponse) => void): ClientUnaryCall;
+    refreshCert(request: RefreshCertRequest, metadata: Metadata, callback: (error: ServiceError | null, response: RefreshCertResponse) => void): ClientUnaryCall;
+    refreshCert(request: RefreshCertRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: RefreshCertResponse) => void): ClientUnaryCall;
+}
+declare const ControlClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): ControlClient;
+    service: typeof ControlService;
+    serviceName: string;
+};
+type Builtin$3 = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$3<T> = T extends Builtin$3 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$3<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$3<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$3<T[K]>;
+} : Partial<T>;
+type KeysOfUnion$3<T> = T extends T ? keyof T : never;
+type Exact$3<P, I extends P> = P extends Builtin$3 ? P : P & {
+    [K in keyof P]: Exact$3<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion$3<P>>]: never;
+};
+interface MessageFns$3<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    create<I extends Exact$3<DeepPartial$3<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact$3<DeepPartial$3<T>, I>>(object: I): T;
+}
+
+type State = "CLOSED" | "OPEN" | "HALF_OPEN";
+declare class CircuitBreakerRegistry {
+    private map;
+    private now;
+    constructor(now?: () => number);
+    canCall(key: string): boolean;
+    recordSuccess(key: string): void;
+    recordFailure(key: string): void;
+    state(key: string): State;
+    reset(key: string): void;
+    private entry;
+    private maybeHalfOpen;
+    private resetWindow;
+}
+
+interface DirectCredentials {
+    caChainDer: Buffer;
+    leafCertDer: Buffer;
+    privateKeyDer: Buffer;
+    notAfterUnix: bigint;
+}
+interface DirectTarget {
+    endpoint: string;
+    serviceId: string;
+    instanceId: string;
+}
+declare class DirectTransport {
+    private creds;
+    private cache;
+    private credsEpoch;
+    constructor(creds: DirectCredentials);
+    updateCredentials(creds: DirectCredentials): void;
+    close(): void;
+    callStream(target: DirectTarget, method: string, payload: Uint8Array, callerService: string, requestId: string, idempotencyKey: string, deadlineMs: number): AsyncIterable<Uint8Array>;
+    callUnary(target: DirectTarget, method: string, payload: Uint8Array, callerService: string, requestId: string, idempotencyKey: string, deadlineMs: number): Promise<Uint8Array>;
+    private clientFor;
+    private evict;
+    cacheSize(): number;
+}
+
+/**
+ * Channel classifies the transport/execution context of an operation.
+ * Mirrors the SQL CHECK constraint in migration 051.
+ * source of truth: migrations/051_operations.up.sql
+ */
+declare enum Channel {
+    CHANNEL_UNSPECIFIED = 0,
+    HTTP = 1,
+    RPC = 2,
+    EVENT = 3,
+    WORKFLOW = 4,
+    JOB = 5,
+    USER = 6,
+    UNRECOGNIZED = -1
+}
+/** Status represents the lifecycle state of an operation. */
+declare enum Status {
+    STATUS_UNSPECIFIED = 0,
+    PENDING = 1,
+    SUCCESS = 2,
+    ERROR = 3,
+    TIMEOUT = 4,
+    ABANDONED = 5,
+    UNRECOGNIZED = -1
+}
+declare enum LogLevel {
+    LOG_LEVEL_UNSPECIFIED = 0,
+    LOG_LEVEL_DEBUG = 1,
+    LOG_LEVEL_INFO = 2,
+    LOG_LEVEL_WARN = 3,
+    LOG_LEVEL_ERROR = 4,
+    UNRECOGNIZED = -1
+}
+declare enum MetricKind {
+    METRIC_KIND_UNSPECIFIED = 0,
+    METRIC_KIND_COUNTER = 1,
+    METRIC_KIND_GAUGE = 2,
+    METRIC_KIND_HISTOGRAM = 3,
+    UNRECOGNIZED = -1
+}
+/**
+ * OpReport is a single operation lifecycle event.
+ * finished_at_ms absent = START frame; present = END frame (T-014).
+ * actor identity is taken from the mTLS cert on the server side (ADR-T-026).
+ * @public — см. ./README.md
+ */
+interface OpReport {
+    /** UUIDv7 canonical string */
+    traceId: string;
+    /** UUIDv7 canonical string */
+    opId: string;
+    /** empty for root */
+    parentOpId: string;
+    channel: Channel;
+    /** per-channel kind value; see enums.go */
+    kind: number;
+    /** T-019 format: "channel.kind:actor/target" */
+    subject: string;
+    /** UUID canonical string, optional */
+    peerServiceId: string;
+    /** idempotency/correlation key per kind */
+    businessKey: string;
+    attempt: number;
+    /** unix-ms */
+    startedAtMs: number;
+    /** unix-ms; absent = START, present = END */
+    finishedAtMs?: number | undefined;
+    status: Status;
+    statusMessage: string;
+    /** per-kind structured meta; cap 8KB */
+    metaJson: Buffer;
+    /** free-form key-value; cap 2KB */
+    attrsJson: Buffer;
+}
+declare const OpReport: MessageFns$2<OpReport>;
+/**
+ * Log is a structured log entry.
+ * trace_id and op_id are optional UUID canonical strings.
+ * @public — см. ./README.md
+ */
+interface Log {
+    atUnixMs: number;
+    level: LogLevel;
+    message: string;
+    /** JSON-encoded Record<string, unknown> */
+    fieldsJson: Buffer;
+    /** UUID canonical, optional */
+    traceId: string;
+    /** UUID canonical, optional (renamed from span_id) */
+    opId: string;
+    instanceId: string;
+    /** 'sdk' | 'console' | 'runtime' */
+    source: string;
+}
+declare const Log: MessageFns$2<Log>;
+/**
+ * MetricPoint is a single metric observation.
+ * @public — см. ./README.md
+ */
+interface MetricPoint {
+    atUnixMs: number;
+    name: string;
+    kind: MetricKind;
+    labels: {
+        [key: string]: string;
+    };
+    instanceId: string;
+    value: number;
+    /** UCUM: 's', 'By', '1' */
+    unit: string;
+    /** [{le, count}] JSON for histograms */
+    bucketsJson: Buffer;
+}
+declare const MetricPoint: MessageFns$2<MetricPoint>;
+/**
+ * PayloadAttachment carries a captured request/response payload.
+ * @public — см. ./README.md
+ */
+interface PayloadAttachment {
+    /** UUID canonical */
+    traceId: string;
+    /** UUID canonical */
+    opId: string;
+    /** 1=IN, 2=OUT */
+    direction: number;
+    bytes: Buffer;
+    originalSize: number;
+    contractHash: string;
+}
+declare const PayloadAttachment: MessageFns$2<PayloadAttachment>;
+type Builtin$2 = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$2<T> = T extends Builtin$2 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$2<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$2<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$2<T[K]>;
+} : Partial<T>;
+type KeysOfUnion$2<T> = T extends T ? keyof T : never;
+type Exact$2<P, I extends P> = P extends Builtin$2 ? P : P & {
+    [K in keyof P]: Exact$2<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion$2<P>>]: never;
+};
+interface MessageFns$2<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    create<I extends Exact$2<DeepPartial$2<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact$2<DeepPartial$2<T>, I>>(object: I): T;
+}
+
+type ChannelCaptureModes = Record<Channel, CaptureMode>;
+declare class WatchStream {
+    private stream;
+    private cache;
+    private instances;
+    private eventSubs;
+    private outgoing;
+    private policy;
+    private _captureModes;
+    private captureModeListeners;
+    private onError;
+    private instanceListeners;
+    private policyListeners;
+    private peersChangeListeners;
+    start(req: RegisterRequest, client: RegistryClient, onError?: (err: Error) => void): void;
+    stop(): void;
+    restart(req: RegisterRequest, client: RegistryClient, onError?: (err: Error) => void): void;
+    snapshot(): ReadonlyMap<string, MethodDescriptor>;
+    instancesSnapshot(): Map<string, ServiceInstanceInfo>;
+    eventSubscriptionsSnapshot(): Map<string, EventSubscriptionDescriptor>;
+    outgoingCallsSnapshot(): Map<string, OutgoingCallDescriptor>;
+    policyEvaluation(): PolicyEvaluation | null;
+    captureModeForChannel(channel: Channel): CaptureMode;
+    onCaptureModes(fn: (modes: ChannelCaptureModes) => void): () => void;
+    private applyCaptureModes;
+    onInstancesChange(fn: (added: ServiceInstanceInfo[], removed: ServiceInstanceInfo[]) => void): () => void;
+    onPolicyEvaluation(fn: (policy: PolicyEvaluation) => void): () => void;
+    onPeersChange(fn: (added: string[], removed: string[]) => void): () => void;
+    private emitInstances;
+    private emitPolicy;
+    private handleEvent;
+}
+
+interface Candidate {
+    descriptor: MethodDescriptor;
+    instance: ServiceInstanceInfo;
+    isUnhealthyAt: Date | null;
+}
+declare class LoadBalancer {
+    private readonly cb;
+    private inflight;
+    private now;
+    private random;
+    constructor(cb: CircuitBreakerRegistry, opts?: {
+        now?: () => number;
+        random?: () => number;
+    });
+    pick(candidates: Candidate[]): Candidate;
+    acquire(instanceId: string): () => void;
+    inflightOf(instanceId: string): number;
+}
+
+declare class InstanceCache {
+    private byService;
+    private instances;
+    private unsubscribe;
+    private watch;
+    bind(watch: WatchStream): void;
+    dispose(): void;
+    pickAll(serviceName: string, methodName: string): Candidate[];
+    descriptorFor(serviceName: string, methodName: string): MethodDescriptor | null;
+    private refresh;
+}
+
+declare class ProxyTransport {
+    private client;
+    constructor(runtimeAddr: string, creds: ChannelCredentials);
+    close(): void;
+    callStream(targetServiceId: string, method: string, payload: Uint8Array, requestId: string, idempotencyKey: string, deadlineMs: number, contractHash: string): AsyncIterable<Uint8Array>;
+    callUnary(targetServiceId: string, method: string, payload: Uint8Array, requestId: string, idempotencyKey: string, deadlineMs: number, contractHash: string): Promise<Uint8Array>;
+}
+
+interface CallOpts {
+    timeout?: string;
+    requestId?: string;
+    transport?: "direct" | "proxy" | "auto";
+    idempotencyKey?: string;
+    retry?: Partial<RetryOpts>;
+}
+interface RetryOpts {
+    maxAttempts: number;
+    baseDelayMs: number;
+    factor: number;
+    maxDelayMs: number;
+    jitter: number;
+}
+interface CallerSchema {
+    pair: SchemaPair;
+    contractHash: string;
+}
+type SchemaResolver = (serviceName: string, methodName: string) => CallerSchema | undefined;
+declare class RpcClient {
+    private readonly proxy;
+    private readonly directTransport;
+    private readonly instances;
+    private readonly resolveSchema;
+    private readonly callerService;
+    private readonly cb;
+    private readonly lb;
+    private readonly sb;
+    constructor(proxy: ProxyTransport, directTransport: DirectTransport | null, instances: InstanceCache, resolveSchema: SchemaResolver, callerService: string, cb: CircuitBreakerRegistry, lb: LoadBalancer, sb: ServiceBridge);
+    stream<Req = unknown, Chunk = unknown>(serviceName: string, methodName: string, payload: Req, opts?: CallOpts): AsyncIterable<Chunk>;
+    call<Req = unknown, Res = unknown>(serviceName: string, methodName: string, payload: Req, opts?: CallOpts): Promise<Res>;
+    private pickCandidate;
+    private shouldUseDirect;
+}
+
+type PolicyViolationSink$1 = (v: {
+    declaration: string;
+    value: string;
+    denySide: string;
+    reason: string;
+}) => void;
+declare class RpcDomain {
+    private readonly registry;
+    private readonly getClient;
+    private readonly onPolicyViolation?;
+    constructor(registry: Registry, getClient: () => RpcClient | null, onPolicyViolation?: PolicyViolationSink$1 | undefined);
+    handle<Req = unknown, Res = unknown>(name: string, fn: RpcHandlerFn<Req, Res>, opts: RpcHandlerOpts): void;
+    handleStream<Req = unknown, Chunk = unknown>(name: string, fn: RpcStreamHandlerFn<Req, Chunk>, opts: RpcHandlerOpts): void;
+    _declareForTests(name: string, streaming?: boolean): void;
+    call<Req = unknown, Res = unknown>(serviceName: string, methodName: string, payload: Req, opts?: CallOpts): Promise<Res>;
+}
+
+interface AdvertiseConfig {
+    host: string;
+    port: number;
+}
+
+type TypedClient = Record<string, ((req: unknown, opts?: CallOpts) => Promise<unknown>) & ((req: unknown, opts?: CallOpts) => AsyncIterable<unknown>)>;
+
+type RingKind = "ops" | "logs" | "metrics" | "payloads";
+type RingMessage = {
+    ops: OpReport;
+    logs: Log;
+    metrics: MetricPoint;
+    payloads: PayloadAttachment;
+};
+interface RingItem<K extends RingKind = RingKind> {
+    id: number;
+    kind: K;
+    message: RingMessage[K];
+    bytes: number;
+}
+type RingBudgets = Partial<Record<RingKind, number>>;
+declare class TelemetryRing {
+    private readonly rings;
+    constructor(budgets?: RingBudgets);
+    push<K extends RingKind>(kind: K, message: RingMessage[K]): void;
+    peek(maxPerKind?: number): RingItem[];
+    commit(items: RingItem[]): void;
+    dropCount(kind: RingKind): number;
+    totalDropCount(): number;
+    size(kind: RingKind): number;
+    bytes(kind: RingKind): number;
+}
+
+type LogFields = Record<string, unknown>;
+declare function makeLogger(ring: TelemetryRing, instanceId: string): {
+    debug(message: string, fields?: LogFields): void;
+    info(message: string, fields?: LogFields): void;
+    warn(message: string, fields?: LogFields): void;
+    error(message: string, fields?: LogFields): void;
+};
+
+type Labels = Record<string, string>;
+declare function makeCounter(ring: TelemetryRing, instanceId: string, name: string, labels?: Labels): {
+    inc(amount?: number): void;
+};
+declare function makeGauge(ring: TelemetryRing, instanceId: string, name: string, labels?: Labels): {
+    set(value: number): void;
+};
+declare function makeHistogram(ring: TelemetryRing, instanceId: string, name: string, unit?: string, labels?: Labels): {
+    observe(value: number): void;
+};
+
+interface StartOpParams {
+    /** Required when called directly without ALS context. Otherwise inherited. */
+    traceId?: string;
+    /** Auto-minted UUIDv7 when omitted. */
+    opId?: string;
+    /** Auto-resolved from currentTraceContext().parentOpId when omitted. */
+    parentOpId?: string;
+    channel: Channel;
+    kind: number;
+    subject: string;
+    peerServiceId?: string;
+    businessKey?: string;
+    attempt?: number;
+    startedAtMs?: number;
+    metaJson?: Buffer;
+    attrsJson?: Buffer;
+    /**
+     * Per-handler capture override. May only narrow the runtime-pushed effective
+     * mode (privacy ordering none < errors < all), never widen it.
+     */
+    captureMode?: CaptureMode;
+    /**
+     * Runtime-pushed effective capture mode (from the registry stream). The
+     * single authority for what may be captured. Defaults to "none" until the
+     * first registry snapshot arrives (fail-safe).
+     */
+    effectiveCaptureMode?: CaptureMode;
+    /**
+     * Per-direction payload byte cap for captured payloads. Defaults to
+     * DEFAULT_PAYLOAD_MAX_BYTES; threaded from ServiceBridgeOptions.payloadMaxBytes.
+     */
+    payloadMaxBytes?: number;
+}
+declare class OpHandle {
+    private readonly ring;
+    private readonly params;
+    private readonly startedAtMs;
+    private ended;
+    private readonly bufferedPayloads;
+    private constructor();
+    /**
+     * Start an operation, enqueue the START frame, return a handle for END.
+     * traceId / parentOpId default to the active TraceContext from ALS
+     * (set via runWithTrace). opId is auto-minted as a fresh UUIDv7.
+     */
+    static start(ring: TelemetryRing, params: StartOpParams): OpHandle;
+    /** Op identifier for this in-flight op (UUIDv7). */
+    get opId(): string;
+    /**
+     * Record the retry attempt count on this in-flight op. The END frame carries
+     * the final value so a single RPC.CALL row reflects how many tries it took
+     * (ADR-0037..0042). No new row is minted per attempt.
+     */
+    setAttempt(attempt: number): void;
+    /** Trace identifier this op belongs to. */
+    get traceId(): string;
+    /**
+     * Capture the inbound (request/input) payload for this op. Direction = IN.
+     * "all" emits immediately; "errors" buffers until end; "none" is a no-op.
+     */
+    captureIn(bytes: Uint8Array, contractHash: string): void;
+    /**
+     * Capture the outbound (response/output) payload for this op. Direction = OUT.
+     */
+    captureOut(bytes: Uint8Array, contractHash: string): void;
+    private capture;
+    private emitPayload;
+    /**
+     * End the operation, enqueue the END frame.
+     * Idempotent — calling end() twice is a no-op.
+     */
+    end(status: Status, statusMessage?: string): void;
+    private flushBufferedPayloads;
+    private enqueueStartFrame;
+    private enqueueEndFrame;
+}
+
+/**
+ * A generic empty message that you can re-use to avoid defining duplicated
+ * empty messages in your APIs. A typical example is to use it as the request
+ * or the response type of an API method. For instance:
+ *
+ *     service Foo {
+ *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+ *     }
+ */
+interface Empty {
+}
+declare const Empty: MessageFns$1<Empty>;
+type Builtin$1 = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$1<T> = T extends Builtin$1 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$1<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$1<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$1<T[K]>;
+} : Partial<T>;
+type KeysOfUnion$1<T> = T extends T ? keyof T : never;
+type Exact$1<P, I extends P> = P extends Builtin$1 ? P : P & {
+    [K in keyof P]: Exact$1<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion$1<P>>]: never;
+};
+interface MessageFns$1<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    create<I extends Exact$1<DeepPartial$1<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact$1<DeepPartial$1<T>, I>>(object: I): T;
+}
+
+interface StartRunRequest {
+    workflowName: string;
+    /** JSON-encoded workflow input */
+    input: Buffer;
+    idempotencyKey: string;
+    /** 0 = no global timeout override */
+    timeoutSec: number;
+    /** X-SB-Trace propagation from caller. */
+    xSbTrace: string;
+    /**
+     * parent_run_id — when non-empty, the request originates from a workflow
+     * step on an in-flight parent run. Runtime enforces dynamic cycle
+     * detection (ADR-W-019) by walking the ancestor chain via this id.
+     * Empty for top-level starts initiated by external callers.
+     */
+    parentRunId: string;
+}
+declare const StartRunRequest: MessageFns<StartRunRequest>;
+interface StartRunResponse {
+    runId: string;
+}
+declare const StartRunResponse: MessageFns<StartRunResponse>;
+interface CancelRunRequest {
+    runId: string;
+}
+declare const CancelRunRequest: MessageFns<CancelRunRequest>;
+interface SignalRunRequest {
+    runId: string;
+    signalName: string;
+    payload: Buffer;
+}
+declare const SignalRunRequest: MessageFns<SignalRunRequest>;
+interface QueryRunRequest {
+    runId: string;
+}
+declare const QueryRunRequest: MessageFns<QueryRunRequest>;
+interface QueryRunResponse {
+    runId: string;
+    status: string;
+    /** JSON-encoded run state map */
+    state: Buffer;
+    steps: StepInfo[];
+}
+declare const QueryRunResponse: MessageFns<QueryRunResponse>;
+interface StepInfo {
+    stepId: string;
+    status: string;
+    output: Buffer;
+    lastError: string;
+    /** step_id of the compensation step, if compensated */
+    compensatedBy: string;
+}
+declare const StepInfo: MessageFns<StepInfo>;
+interface AwaitRunRequest {
+    runId: string;
+}
+declare const AwaitRunRequest: MessageFns<AwaitRunRequest>;
+interface RunStatusUpdate {
+    runId: string;
+    status: string;
+    /** JSON-encoded final state; non-empty only on terminal status */
+    state: Buffer;
+}
+declare const RunStatusUpdate: MessageFns<RunStatusUpdate>;
+interface ReplayRunRequest {
+    runId: string;
+    fromStepId: string;
+}
+declare const ReplayRunRequest: MessageFns<ReplayRunRequest>;
+interface ReplayRunResponse {
+    /** new run id */
+    runId: string;
+}
+declare const ReplayRunResponse: MessageFns<ReplayRunResponse>;
+interface SubscribeRequest {
+    /** UUID */
+    serviceId: string;
+    /** UUID */
+    instanceId: string;
+}
+declare const SubscribeRequest: MessageFns<SubscribeRequest>;
+interface RunAssignment {
+    runId: string;
+    workflowName: string;
+    fingerprint: string;
+    /** canonical JSON graph */
+    frozenPlan: Buffer;
+    /** JSON-encoded workflow input */
+    input: Buffer;
+    /** JSON-encoded current state (checkpointed outputs) */
+    state: Buffer;
+    leaseEpoch: number;
+    maxParallelism: number;
+    /** X-SB-Trace propagation — workflow root op. */
+    xSbTrace: string;
+    /** Compensation: if set, SDK must execute compensation steps. */
+    compensating: boolean;
+    /** cancel_reason mirrors workflow_runs.cancel_reason. Values: '' | 'user_cancel' | 'step_failure'. */
+    cancelReason: string;
+}
+declare const RunAssignment: MessageFns<RunAssignment>;
+interface BeginStepRequest {
+    runId: string;
+    stepId: string;
+    /** empty for top-level steps */
+    parentStepId: string;
+    /** call|publish|sleep|wait_event|wait_signal|workflow|parallel|sequence|local */
+    kind: string;
+    /** JSON-encoded resolved inputs */
+    inputSnapshot: Buffer;
+    leaseEpoch: number;
+    /** UUID of the claiming SDK instance */
+    instanceId: string;
+}
+declare const BeginStepRequest: MessageFns<BeginStepRequest>;
+interface BeginStepResponse {
+    /**
+     * If the step was already completed (idempotent replay), cached_output is
+     * non-nil and the SDK must use it without re-executing.
+     */
+    cachedOutput: Buffer;
+    alreadyDone: boolean;
+    leaseEpoch: number;
+}
+declare const BeginStepResponse: MessageFns<BeginStepResponse>;
+interface CompleteStepRequest {
+    runId: string;
+    stepId: string;
+    /** JSON-encoded step output */
+    output: Buffer;
+    leaseEpoch: number;
+}
+declare const CompleteStepRequest: MessageFns<CompleteStepRequest>;
+interface FailStepRequest {
+    runId: string;
+    stepId: string;
+    errorCode: string;
+    errorMessage: string;
+    leaseEpoch: number;
+    retriable: boolean;
+}
+declare const FailStepRequest: MessageFns<FailStepRequest>;
+interface FailStepResponse {
+    /** Runtime's decision after the failure. */
+    nextAction: string;
+    retryDelaySec: number;
+}
+declare const FailStepResponse: MessageFns<FailStepResponse>;
+interface ParkRequest {
+    runId: string;
+    stepId: string;
+    leaseEpoch: number;
+    sleep?: SleepSpec | undefined;
+    eventWait?: EventWaitSpec | undefined;
+    signalWait?: SignalWaitSpec | undefined;
+    nestedRun?: NestedRunSpec | undefined;
+}
+declare const ParkRequest: MessageFns<ParkRequest>;
+interface SleepSpec {
+    durationSec: number;
+}
+declare const SleepSpec: MessageFns<SleepSpec>;
+interface EventWaitSpec {
+    event: string;
+    /** JSON-encoded {"$.path": "expected"} filter; empty = match all */
+    filterJson: string;
+    /** 0 = no timeout */
+    timeoutSec: number;
+}
+declare const EventWaitSpec: MessageFns<EventWaitSpec>;
+interface SignalWaitSpec {
+    signal: string;
+    /** 0 = no timeout */
+    timeoutSec: number;
+}
+declare const SignalWaitSpec: MessageFns<SignalWaitSpec>;
+interface NestedRunSpec {
+    childRunId: string;
+}
+declare const NestedRunSpec: MessageFns<NestedRunSpec>;
+interface CompleteRunRequest {
+    runId: string;
+    /** JSON-encoded final state map (output of last step) */
+    finalState: Buffer;
+    leaseEpoch: number;
+    /**
+     * terminal_status: 'success' | 'failed_compensated' | 'cancelled'.
+     * If empty, defaults to 'success'.
+     */
+    terminalStatus: string;
+}
+declare const CompleteRunRequest: MessageFns<CompleteRunRequest>;
+interface HeartbeatRequest {
+    runId: string;
+    /** UUID */
+    instanceId: string;
+    leaseEpoch: number;
+}
+declare const HeartbeatRequest: MessageFns<HeartbeatRequest>;
+/**
+ * Workflows — durable workflow execution service.
+ * Caller-side RPCs: Start, Cancel, Signal, Query, Await, Replay.
+ * Owner-side RPCs: Subscribe, BeginStep, CompleteStep, FailStep, Park, Heartbeat.
+ */
+type WorkflowsService = typeof WorkflowsService;
+declare const WorkflowsService: {
+    /** Caller-side */
+    readonly start: {
+        readonly path: "/servicebridge.v1.Workflows/Start";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: StartRunRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => StartRunRequest;
+        readonly responseSerialize: (value: StartRunResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => StartRunResponse;
+    };
+    readonly cancel: {
+        readonly path: "/servicebridge.v1.Workflows/Cancel";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: CancelRunRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => CancelRunRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+    readonly signal: {
+        readonly path: "/servicebridge.v1.Workflows/Signal";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: SignalRunRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => SignalRunRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+    readonly query: {
+        readonly path: "/servicebridge.v1.Workflows/Query";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: QueryRunRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => QueryRunRequest;
+        readonly responseSerialize: (value: QueryRunResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => QueryRunResponse;
+    };
+    readonly await: {
+        readonly path: "/servicebridge.v1.Workflows/Await";
+        readonly requestStream: false;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: AwaitRunRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => AwaitRunRequest;
+        readonly responseSerialize: (value: RunStatusUpdate) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => RunStatusUpdate;
+    };
+    readonly replay: {
+        readonly path: "/servicebridge.v1.Workflows/Replay";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ReplayRunRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ReplayRunRequest;
+        readonly responseSerialize: (value: ReplayRunResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ReplayRunResponse;
+    };
+    /** Owner-side */
+    readonly subscribe: {
+        readonly path: "/servicebridge.v1.Workflows/Subscribe";
+        readonly requestStream: false;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: SubscribeRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => SubscribeRequest;
+        readonly responseSerialize: (value: RunAssignment) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => RunAssignment;
+    };
+    readonly beginStep: {
+        readonly path: "/servicebridge.v1.Workflows/BeginStep";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: BeginStepRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => BeginStepRequest;
+        readonly responseSerialize: (value: BeginStepResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => BeginStepResponse;
+    };
+    readonly completeStep: {
+        readonly path: "/servicebridge.v1.Workflows/CompleteStep";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: CompleteStepRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => CompleteStepRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+    readonly completeRun: {
+        readonly path: "/servicebridge.v1.Workflows/CompleteRun";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: CompleteRunRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => CompleteRunRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+    readonly failStep: {
+        readonly path: "/servicebridge.v1.Workflows/FailStep";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: FailStepRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => FailStepRequest;
+        readonly responseSerialize: (value: FailStepResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => FailStepResponse;
+    };
+    readonly park: {
+        readonly path: "/servicebridge.v1.Workflows/Park";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ParkRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ParkRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+    readonly heartbeat: {
+        readonly path: "/servicebridge.v1.Workflows/Heartbeat";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: HeartbeatRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => HeartbeatRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+};
+interface WorkflowsClient extends Client {
+    /** Caller-side */
+    start(request: StartRunRequest, callback: (error: ServiceError | null, response: StartRunResponse) => void): ClientUnaryCall;
+    start(request: StartRunRequest, metadata: Metadata, callback: (error: ServiceError | null, response: StartRunResponse) => void): ClientUnaryCall;
+    start(request: StartRunRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: StartRunResponse) => void): ClientUnaryCall;
+    cancel(request: CancelRunRequest, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    cancel(request: CancelRunRequest, metadata: Metadata, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    cancel(request: CancelRunRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    signal(request: SignalRunRequest, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    signal(request: SignalRunRequest, metadata: Metadata, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    signal(request: SignalRunRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    query(request: QueryRunRequest, callback: (error: ServiceError | null, response: QueryRunResponse) => void): ClientUnaryCall;
+    query(request: QueryRunRequest, metadata: Metadata, callback: (error: ServiceError | null, response: QueryRunResponse) => void): ClientUnaryCall;
+    query(request: QueryRunRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: QueryRunResponse) => void): ClientUnaryCall;
+    await(request: AwaitRunRequest, options?: Partial<CallOptions>): ClientReadableStream<RunStatusUpdate>;
+    await(request: AwaitRunRequest, metadata?: Metadata, options?: Partial<CallOptions>): ClientReadableStream<RunStatusUpdate>;
+    replay(request: ReplayRunRequest, callback: (error: ServiceError | null, response: ReplayRunResponse) => void): ClientUnaryCall;
+    replay(request: ReplayRunRequest, metadata: Metadata, callback: (error: ServiceError | null, response: ReplayRunResponse) => void): ClientUnaryCall;
+    replay(request: ReplayRunRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: ReplayRunResponse) => void): ClientUnaryCall;
+    /** Owner-side */
+    subscribe(request: SubscribeRequest, options?: Partial<CallOptions>): ClientReadableStream<RunAssignment>;
+    subscribe(request: SubscribeRequest, metadata?: Metadata, options?: Partial<CallOptions>): ClientReadableStream<RunAssignment>;
+    beginStep(request: BeginStepRequest, callback: (error: ServiceError | null, response: BeginStepResponse) => void): ClientUnaryCall;
+    beginStep(request: BeginStepRequest, metadata: Metadata, callback: (error: ServiceError | null, response: BeginStepResponse) => void): ClientUnaryCall;
+    beginStep(request: BeginStepRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: BeginStepResponse) => void): ClientUnaryCall;
+    completeStep(request: CompleteStepRequest, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    completeStep(request: CompleteStepRequest, metadata: Metadata, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    completeStep(request: CompleteStepRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    completeRun(request: CompleteRunRequest, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    completeRun(request: CompleteRunRequest, metadata: Metadata, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    completeRun(request: CompleteRunRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    failStep(request: FailStepRequest, callback: (error: ServiceError | null, response: FailStepResponse) => void): ClientUnaryCall;
+    failStep(request: FailStepRequest, metadata: Metadata, callback: (error: ServiceError | null, response: FailStepResponse) => void): ClientUnaryCall;
+    failStep(request: FailStepRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: FailStepResponse) => void): ClientUnaryCall;
+    park(request: ParkRequest, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    park(request: ParkRequest, metadata: Metadata, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    park(request: ParkRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    heartbeat(request: HeartbeatRequest, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    heartbeat(request: HeartbeatRequest, metadata: Metadata, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    heartbeat(request: HeartbeatRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+}
+declare const WorkflowsClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): WorkflowsClient;
+    service: typeof WorkflowsService;
+    serviceName: string;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+
+type JsonExpression = string | number | boolean | null | {
+    literal: string;
+} | JsonExpression[] | {
+    [key: string]: JsonExpression;
+};
+type Predicate = string | {
+    not: Predicate;
+} | {
+    equals: [JsonExpression, JsonExpression];
+} | {
+    in: [JsonExpression, JsonExpression];
+} | {
+    and: Predicate[];
+} | {
+    or: Predicate[];
+};
+
+interface CompensateSpec {
+    type?: "call" | "publish";
+    service?: string;
+    method?: string;
+    event?: string;
+    input: JsonExpression;
+    retry?: Partial<RetryOpts>;
+    idempotencyKey?: string;
+}
+
+interface WorkflowStartOpts {
+    idempotencyKey?: string;
+    timeoutSec?: number;
+    parentRunId?: string;
+}
+
+type TemplatableOpts<T> = {
+    [K in keyof T]: T[K] | JsonExpression;
+};
+type TemplatableCallOpts = TemplatableOpts<CallOpts>;
+type TemplatablePublishOpts = TemplatableOpts<PublishOpts>;
+type TemplatableWorkflowStartOpts = TemplatableOpts<WorkflowStartOpts>;
+interface StepControlFields {
+    id: string;
+    waitFor?: string[];
+    when?: Predicate;
+    compensate?: CompensateSpec;
+    timeoutSec?: number;
+    retry?: Partial<RetryOpts>;
+}
+interface CallStep extends StepControlFields {
+    type: "call";
+    service: string | JsonExpression;
+    method: string | JsonExpression;
+    input: JsonExpression;
+    opts?: TemplatableCallOpts;
+}
+interface PublishStep extends StepControlFields {
+    type: "publish";
+    event: string | JsonExpression;
+    input: JsonExpression;
+    opts?: TemplatablePublishOpts;
+}
+interface SleepStep extends StepControlFields {
+    type: "sleep";
+    durationSec: number;
+}
+interface WaitEventStep extends StepControlFields {
+    type: "wait_event";
+    event: string;
+    filter?: Record<string, JsonExpression>;
+}
+interface WaitSignalStep extends StepControlFields {
+    type: "wait_signal";
+    signal: string;
+}
+interface WorkflowStep extends StepControlFields {
+    type: "workflow";
+    workflow: string | JsonExpression;
+    input: JsonExpression;
+    opts?: TemplatableWorkflowStartOpts;
+}
+interface ForEachSpec {
+    from: JsonExpression;
+    as: string;
+}
+interface ParallelStep extends StepControlFields {
+    type: "parallel";
+    steps: Step[];
+    forEach?: ForEachSpec;
+}
+interface SequenceStep extends StepControlFields {
+    type: "sequence";
+    steps: Step[];
+    forEach?: ForEachSpec;
+}
+interface LocalStep extends StepControlFields {
+    type: "local";
+    fn: (state: Record<string, unknown>) => Promise<unknown>;
+}
+type Step = CallStep | PublishStep | SleepStep | WaitEventStep | WaitSignalStep | WorkflowStep | ParallelStep | SequenceStep | LocalStep;
+type SchemaShape = Record<string, unknown>;
+interface WorkflowDef {
+    input?: SchemaShape;
+    steps: Step[];
+    retry?: Partial<RetryOpts>;
+    maxParallelism?: number;
+    timeoutSec?: number;
+}
+
+type PolicyViolationSink = (v: {
+    declaration: string;
+    value: string;
+    denySide: string;
+    reason: string;
+}) => void;
+declare class WorkflowDomain {
+    private readonly registry;
+    private readonly onPolicyViolation?;
+    private rpc;
+    constructor(registry: Registry, onPolicyViolation?: PolicyViolationSink | undefined);
+    _attachRpc(rpc: WorkflowsClient): void;
+    handle(name: string, def: WorkflowDef, opts?: WorkflowHandlerOpts): void;
+    start(name: string, input: unknown, opts?: WorkflowStartOpts): Promise<{
+        runId: string;
+    }>;
+    signal(runId: string, signalName: string, payload: unknown): Promise<void>;
+    cancel(runId: string): Promise<void>;
+    await(runId: string): Promise<Record<string, unknown>>;
+    query(runId: string): Promise<{
+        status: string;
+        state: Record<string, unknown>;
+        steps: Array<{
+            stepId: string;
+            status: string;
+            output: unknown;
+            lastError: string;
+            compensatedBy?: string;
+        }>;
+    }>;
+    replay(runId: string, opts?: {
+        fromStepId?: string;
+    }): Promise<{
+        runId: string;
+    }>;
+    private requireRpc;
+}
+
+interface BootstrapKey {
+    keyID: Buffer;
+    secret: Buffer;
+    caCertDer: Buffer;
+}
+
+interface ProvisionResult {
+    certDer: Buffer;
+    caChainDer: Buffer;
+    serviceId: string;
+    serviceName: string;
+    instanceId: string;
+    notAfterUnix: bigint;
+    privateKey: CryptoKey;
+    privateKeyDer: Buffer;
+}
+/**
+ * Runs the full Provision flow:
+ *   1. Use the CA cert embedded in the bootstrap key as the trusted root.
+ *   2. Generate keypair + CSR.
+ *   3. Call Bootstrap.Provision over a gRPC channel rooted at that CA.
+ */
+declare function provision(url: string, key: BootstrapKey): Promise<ProvisionResult>;
+/**
+ * Reissues a leaf cert via Control.RefreshCert under the existing mTLS channel.
+ * No argon2 — identity is proven by the live client cert. The runtime generates
+ * a fresh instance_id (preserving overlap-rotation semantics); the CA cert
+ * and parent service identity carry over from the previous provision.
+ *
+ * Caller must reuse the existing mTLS ControlClient — RefreshCert is in the
+ * default-deny set and rejects unauthenticated channels.
+ */
+declare function refresh(client: ControlClient, previous: ProvisionResult): Promise<ProvisionResult>;
+
+/** @public см. ./README.md */
+declare class ServiceBridgeError extends Error {
+    readonly code: number;
+    constructor(scope: string, cause: unknown);
+}
+
+/**
+ * Entry в карте `sb.serviceMap()`. Группирует видимые caller'у методы сервиса
+ * (`methods`) и его текущих живых инстансов с их endpoint'ами (`instances`).
+ * `httpEndpoint` поле каждого инстанса — публичный HTTP host:port пользователя
+ * (ADR 0001), пустая строка если у инстанса нет HTTP-интеграции.
+ */
+interface ServiceMapEntry {
+    methods: MethodDescriptor[];
+    instances: ServiceInstanceInfo[];
+    eventSubscriptions: EventSubscriptionDescriptor[];
+    outgoingCalls: OutgoingCallDescriptor[];
+}
+
+/**
+ * TelemetryAPI is the public surface for emitting telemetry from user code
+ * and from internal subsystems (RPC, HTTP plugins, events, workflow, jobs).
+ *
+ * @public — см. ../telemetry/README.md
+ */
+interface TelemetryAPI {
+    /** Start an op; returns a handle to `.end(status, message?)`. */
+    startOp(params: StartOpParams): OpHandle;
+    /**
+     * Runtime-pushed effective payload capture mode for the given op channel.
+     * "none" until the first registry snapshot arrives (fail-safe). Read-only
+     * introspection — capture itself is applied automatically inside startOp.
+     */
+    captureModeForChannel(channel: Channel): CaptureMode;
+    log: ReturnType<typeof makeLogger>;
+    counter(name: string, labels?: Labels): ReturnType<typeof makeCounter>;
+    gauge(name: string, labels?: Labels): ReturnType<typeof makeGauge>;
+    histogram(name: string, unit?: string, labels?: Labels): ReturnType<typeof makeHistogram>;
+}
+interface ConnectedEvent {
+    sessionId: string;
+    serviceId: string;
+    serviceName: string;
+}
+/**
+ * Identity of the current live session. Populated on Welcome (start + every
+ * successful overlap rotation), cleared on stop / stream end. Read via
+ * `ServiceBridge.identity()`.
+ */
+interface Identity {
+    sessionId: string;
+    serviceId: string;
+    serviceName: string;
+    instanceId: string;
+}
+interface ReconnectingEvent {
+    attempt: number;
+    delayMs: number;
+    reason: string;
+}
+interface DisconnectedEvent {
+    reason: string;
+    error?: ServiceBridgeError;
+}
+/**
+ * One violation reported by the runtime in `RegistrySnapshot.policy.warnings`.
+ * Emitted via `sb.on("policy_violation", ...)` and logged via console.warn.
+ *
+ * Fields mirror `pb.PolicyViolation`:
+ *
+ * - `declaration` — what was declared, e.g. `rpc.call`, `event.handle`,
+ *   `event.publish`, `rpc.handle` (capability).
+ * - `value` — concrete value, e.g. `payments/charge`, `orders.*`.
+ * - `denySide` — `capability` | `self_egress` | `self_acceptance` | `peer_acceptance`.
+ * - `reason` — human-readable explanation from the runtime.
+ */
+interface PolicyViolationEvent {
+    declaration: string;
+    value: string;
+    denySide: string;
+    reason: string;
+}
+type EventMap = {
+    connected: ConnectedEvent;
+    reconnecting: ReconnectingEvent;
+    disconnected: DisconnectedEvent;
+    /**
+     * Fired once per warning when the runtime sends a PolicyEvaluation in the
+     * registry snapshot (after `start()` or after operator changes policy).
+     */
+    policy_violation: PolicyViolationEvent;
+};
+type Handler<K extends keyof EventMap> = (event: EventMap[K]) => void;
+/** Public configuration. Documented in `./README.md` (Public contract). */
+interface ServiceBridgeOptions {
+    reconnectIntervalMs?: number;
+    reconnectAttempts?: number;
+    /**
+     * Advertise config for the inbound Call RPC server.
+     *
+     * - `{ host, port }` — explicit (recommended for prod, required in k8s with POD_IP)
+     * - `undefined` (default) — bind "127.0.0.1" on a free port. Local dev
+     *   friendly; logs a warning when falling back to loopback so cross-host
+     *   limitations are visible.
+     * - `false` — explicit caller-only mode: do not bind any inbound server.
+     *   Set this when you know the instance never serves RPC.
+     */
+    advertise?: AdvertiseConfig | false;
+    /**
+     * Default options applied to every `sb.rpc.call()` unless overridden.
+     */
+    callDefaults?: CallOpts;
+    /**
+     * ADR-0014: when `true`, any policy violation reported by the runtime in
+     * the registry snapshot's `PolicyEvaluation.warnings` makes `start()`
+     * surface a `disconnected` event with reason='policy' and the SDK stops.
+     * Default `false` — warnings only (logged via console.warn + emitted as
+     * `policy_violation` events).
+     */
+    failOnPolicyViolation?: boolean;
+    /**
+     * Emit telemetry (ops, logs, metrics) to the runtime. `false` fully disables
+     * the telemetry transport — the ring still buffers but nothing is drained.
+     * Default `true`.
+     */
+    telemetry?: boolean;
+    /** Ops-ring byte budget. Default 262144 (256 KiB). */
+    telemetryRingSize?: number;
+    /** Local SQLite outbox directory. Default "./.servicebridge". */
+    dataDir?: string;
+    /** Max rows kept in the event outbox before publish back-pressures. Default 100000. */
+    maxOutboxRows?: number;
+    /** Rows the events drainer pulls per tick. Default 50. */
+    eventsDrainerBatch?: number;
+    /** Max in-flight inbound events the subscriber processes concurrently. Default 32. */
+    eventsMaxInFlight?: number;
+    /** Per-direction captured-payload byte cap. Default 65536. */
+    payloadMaxBytes?: number;
+}
+/**
+ * @internal см. ./README.md
+ */
+interface ServiceBridgeInternalHooks extends ServiceBridgeOptions {
+    certRefreshLeadMs?: number;
+    certRefreshJitterMs?: number;
+    rotationHandshakeTimeoutMs?: number;
+    provisionFn?: typeof provision;
+    refreshFn?: typeof refresh;
+    clientFactory?: (url: string, creds: grpc.ChannelCredentials) => ControlClient;
+    registryClientFactory?: (url: string, creds: grpc.ChannelCredentials) => RegistryClient;
+}
+/**
+ * ServiceBridge manages the full connection lifecycle:
+ * 1. Parse the bootstrap key.
+ * 2. Provision (Bootstrap.Provision) to get a leaf cert.
+ * 3. Open a mTLS gRPC channel with the cert.
+ * 4. Open (Control.Open) for the server-streamed Welcome / Drain signals.
+ * 5. Auto-reconnect with configurable attempts.
+ * 6. Cert rotation: overlap — new channel up AND Welcome received on the new
+ *    stream before closing the old stream.
+ */
+declare class ServiceBridge {
+    private readonly url;
+    private readonly rawKey;
+    private readonly opts;
+    private readonly handlers;
+    private stopped;
+    private session;
+    private controlClient;
+    private lastProvision;
+    private certRefreshTimer;
+    private currentIdentity;
+    private readonly _registry;
+    private readonly _watchStream;
+    private readonly _instanceCache;
+    private readonly _schemaRegistry;
+    private _started;
+    private _callServer;
+    private _proxyTransport;
+    private _directTransport;
+    private _rpcClient;
+    private readonly _cb;
+    private readonly _lb;
+    private _eventsClient;
+    private _storage;
+    private _publisher;
+    private _drainer;
+    private _subscriber;
+    private _workflowsClient;
+    private _workflowSubscriber;
+    private _jobsClient;
+    private _jobSubscriber;
+    private readonly _telemetryEnabled;
+    private readonly _telemetryRing;
+    private readonly _telemetryApi;
+    private _telemetryClient;
+    private _telemetryTransport;
+    private _processSampler;
+    private _telemetryInstanceId;
+    private readonly _schemaIndexAdapter;
+    /** RPC domain — incoming handlers and outgoing calls. */
+    readonly rpc: RpcDomain;
+    /** Event domain — define published events, subscribe, publish. */
+    readonly event: EventDomain;
+    /** Workflow domain — register workflow handlers (stub; full impl in workflows.md). */
+    readonly workflow: WorkflowDomain;
+    /** Job domain — register scheduled job handlers via `.handle(name, opts, fn)`. */
+    readonly job: JobDomain;
+    /** Declares outgoing dependencies (rpc/workflows/http). Call before start(). */
+    service(serviceName: string, deps: ServiceDeps): void;
+    constructor(url: string, key: string, options?: ServiceBridgeOptions | ServiceBridgeInternalHooks);
+    /**
+     * Surface a policy denial uniformly: log via console.warn and emit
+     * `policy_violation`. Shared by the registration evaluation (gate #0
+     * warnings) and call-time denials (rpc.call / workflow.run / event.publish).
+     */
+    private emitPolicyViolation;
+    /**
+     * Route collector — для использования ТОЛЬКО HTTP-интеграциями
+     * (`servicebridge/express`, `servicebridge/fastify`, `servicebridge/hono`).
+     * Прикладной код не вызывает это напрямую: роуты живут в Express/Fastify/Hono.
+     * См. ADR 0001 и userDocs/integrations.md.
+     */
+    get routes(): RouteCollector;
+    /**
+     * Telemetry API surface — emit ops, logs, metrics from user code.
+     * Resources buffer in the ring before start(); the transport drains once
+     * Welcome arrives. parent_op_id/trace_id are inherited from the active
+     * ALS TraceContext.
+     *
+     * @public — см. ../telemetry/README.md
+     */
+    get telemetry(): TelemetryAPI;
+    /**
+     * Structured logger — auto-injects instance_id and trace_id/op_id from the
+     * active context. Kept as a top-level convenience surface; equivalent to
+     * `sb.telemetry.log`.
+     */
+    get logger(): {
+        debug(message: string, fields?: LogFields): void;
+        info(message: string, fields?: LogFields): void;
+        warn(message: string, fields?: LogFields): void;
+        error(message: string, fields?: LogFields): void;
+    };
+    /**
+     * Instance ID текущей сессии (`telemetry_spans.instance_id`) — 12-символьная
+     * Crockford-base32 строка. До `start()` / до первого RegisterResponse
+     * возвращает пустую строку. Используется HTTP-плагинами для автотрейсинга.
+     * @public
+     */
+    instanceIdString(): string;
+    /**
+     * Дёргается `RouteCollector.publishHttp(...)` после `sb.start()`, когда
+     * интеграция узнала фактический host:port HTTP-сервера и хочет, чтобы
+     * runtime увидел его моментально (а не ждал natural reconnect).
+     *
+     * Безопасно если `start()` ещё не вызван — endpoint просто оседает в
+     * Registry и попадёт в первый RegisterRequest.
+     */
+    private onRegistrationChanged;
+    on<K extends keyof EventMap>(event: K, handler: Handler<K>): this;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Registers a SchemaPair on the caller side for the given (service, method).
+     * Must be called before `sb.rpc.call()` is invoked for that method. The schema
+     * MUST match the one used by the target service (same .proto file).
+     *
+     * For an ergonomic alternative that handles dependency declaration, schema
+     * loading and typed method calls in one shot — see `client()`.
+     */
+    useSchema(serviceName: string, methodName: string, spec: SchemaSpec): Promise<void>;
+    /**
+     * High-level typed caller: reads the `.proto` file once, registers all
+     * methods in its `service` block as outgoing dependencies, loads schemas,
+     * and returns a proxy object with typed method calls.
+     *
+     * ```ts
+     * const payment = await sb.client("payment-svc", "./payment.proto");
+     * await sb.start();
+     * const res = await payment.Charge({ userId: "u", amount: 100 });
+     *
+     * // streaming method auto-detected from `rpc Generate(...) returns (stream Chunk)`
+     * for await (const chunk of payment.Generate({ prompt: "..." })) { ... }
+     * ```
+     *
+     * Must be called BEFORE `start()` — declared dependencies are sent in the
+     * initial RegisterRequest. Pass `methods` to bind only a subset; otherwise
+     * every method in any service block is exposed.
+     */
+    client(serviceName: string, protoFile: string, opts?: {
+        methods?: string[];
+        callDefaults?: CallOpts;
+    }): Promise<TypedClient>;
+    /**
+     * Server-side streaming RPC. Returns an AsyncIterable of decoded chunks.
+     * Cancelling the for-await loop (break/return) closes the underlying gRPC
+     * stream which propagates to the callee.
+     */
+    stream<Req = unknown, Chunk = unknown>(serviceName: string, methodName: string, payload: Req, opts?: CallOpts): AsyncIterable<Chunk>;
+    /**
+     * Returns the identity of the current live session, or `null` if not
+     * connected (before first Welcome, during reconnect, or after stop()).
+     */
+    identity(): Identity | null;
+    /**
+     * Live snapshot of the service registry grouped by serviceName. Each entry
+     * carries both the method descriptors visible to this caller (subject to
+     * outgoing-dep subscriptions) и список текущих живых инстансов с их
+     * endpoint'ами (`callEndpoint` для gRPC, `httpEndpoint` для HTTP-сервера
+     * пользователя по ADR 0001).
+     */
+    serviceMap(): ReadonlyMap<string, ServiceMapEntry>;
+    /**
+     * ADR-0014: the caller's last-known PolicyEvaluation as pushed by the
+     * runtime via `RegistrySnapshot.policy`. `null` until the first snapshot
+     * frame arrives. Updated automatically when the operator edits policy and
+     * Postgres NOTIFY fires → runtime re-emits.
+     */
+    policyEvaluation(): PolicyEvaluation | null;
+    private emit;
+    private connect;
+    private openSession;
+    private ensureRpcReady;
+    private buildMTLSCredentials;
+    private maybeStartWorkflowSubscriber;
+    private readonly runHandlerWithTrace;
+    private maybeStartJobSubscriber;
+    private handlersForSubscriber;
+    private scheduleCertRefresh;
+    /**
+     * Overlap rotation:
+     *   1. Re-provision (new cert).
+     *   2. Open new mTLS channel + Control.Open stream.
+     *   3. Wait for Welcome on the new stream.
+     *   4. Only then close the old session.
+     *
+     * On failure: schedule a reconnect so the application sees a `reconnecting`
+     * event; the next reconnect cycle will re-provision and proceed.
+     */
+    private rotateCert;
+    private scheduleReconnect;
+    private clearTimers;
+}
+
+export { type AdvertiseConfig as A, type CallOpts as C, type DeclaredDep as D, EventDomain as E, type Identity as I, JobDomain as J, MethodDescriptor as M, type OverlapPolicy as O, type PolicyViolationEvent as P, type ReconnectingEvent as R, type SchemaSpec as S, type Trigger as T, WorkflowDomain as W, type CatchupPolicy as a, type ConnectedEvent as b, type CronTrigger as c, type DelayedTrigger as d, type DisconnectedEvent as e, type IntervalTrigger as f, type JobHandler as g, type JobHandlerCtx as h, type JobOpts as i, MethodType as j, type PublishOpts as k, type RetryOpts as l, type RetryPolicy as m, RpcDomain as n, type RpcHandlerOpts as o, ServiceBridge as p, ServiceBridgeError as q, type ServiceBridgeOptions as r, type ServiceDeps as s, type TypedClient as t, type WorkflowHandlerOpts as u, OpHandle as v };