@f-inverse/jammi-client 0.49.0 → 0.50.0

package/dist/gen/jammi/v1/gang_pb.d.ts

@@ -0,0 +1,730 @@
+import type { GenEnum, GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv2";
+import type { Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file jammi/v1/gang.proto.
+ */
+export declare const file_jammi_v1_gang: GenFile;
+/**
+ * A control frame a rank sends on its `RunRank` stream.
+ *
+ * @generated from message jammi.v1.gang.RankControl
+ */
+export type RankControl = Message<"jammi.v1.gang.RankControl"> & {
+    /**
+     * @generated from oneof jammi.v1.gang.RankControl.control
+     */
+    control: {
+        /**
+         * @generated from field: jammi.v1.gang.Assign assign = 1;
+         */
+        value: Assign;
+        case: "assign";
+    } | {
+        /**
+         * @generated from field: jammi.v1.gang.Cancel cancel = 2;
+         */
+        value: Cancel;
+        case: "cancel";
+    } | {
+        /**
+         * The round protocol, coordinator → member (all after `Admitted`).
+         * The coordinator's rank-ordered fold of round `round`, followed by
+         * `chunk_count` `round_chunk` frames carrying its Arrow IPC bytes.
+         *
+         * @generated from field: jammi.v1.gang.RoundPayload round_result = 3;
+         */
+        value: RoundPayload;
+        case: "roundResult";
+    } | {
+        /**
+         * @generated from field: jammi.v1.gang.RoundChunk round_chunk = 4;
+         */
+        value: RoundChunk;
+        case: "roundChunk";
+    } | {
+        /**
+         * The coordinator observed every member's `RoundAck` for this round:
+         * apply it. A member that never receives this for a round it ACKed
+         * applies nothing for that round.
+         *
+         * @generated from field: jammi.v1.gang.RoundCommit round_commit = 5;
+         */
+        value: RoundCommit;
+        case: "roundCommit";
+    } | {
+        /**
+         * The round is abandoned on every rank; `detail` is the gang's fault.
+         *
+         * @generated from field: jammi.v1.gang.RoundFault round_fault = 6;
+         */
+        value: RoundFault;
+        case: "roundFault";
+    } | {
+        /**
+         * The transport every rank of this gang moves its round bytes by: the
+         * coordinator's decision, sent to every member once all are admitted
+         * and before round 0 — the first frame after `Admitted`.
+         *
+         * @generated from field: jammi.v1.gang.Bind bind = 7;
+         */
+        value: Bind;
+        case: "bind";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message jammi.v1.gang.RankControl.
+ * Use `create(RankControlSchema)` to create a new message.
+ */
+export declare const RankControlSchema: GenMessage<RankControl>;
+/**
+ * How a gang's round bytes move (`jammi_ai::fine_tune::collective::transport`).
+ * The control round — agreement, fault, commit — is the same on either.
+ *
+ * @generated from message jammi.v1.gang.Bind
+ */
+export type Bind = Message<"jammi.v1.gang.Bind"> & {
+    /**
+     * @generated from oneof jammi.v1.gang.Bind.transport
+     */
+    transport: {
+        /**
+         * The bytes ride the round frames themselves.
+         *
+         * @generated from field: jammi.v1.gang.InlineTransport inline = 1;
+         */
+        value: InlineTransport;
+        case: "inline";
+    } | {
+        /**
+         * The round frames carry descriptors only; once they agree, the bytes
+         * move by an NCCL all-gather among the ranks.
+         *
+         * @generated from field: jammi.v1.gang.NcclTransport nccl = 2;
+         */
+        value: NcclTransport;
+        case: "nccl";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message jammi.v1.gang.Bind.
+ * Use `create(BindSchema)` to create a new message.
+ */
+export declare const BindSchema: GenMessage<Bind>;
+/**
+ * @generated from message jammi.v1.gang.InlineTransport
+ */
+export type InlineTransport = Message<"jammi.v1.gang.InlineTransport"> & {};
+/**
+ * Describes the message jammi.v1.gang.InlineTransport.
+ * Use `create(InlineTransportSchema)` to create a new message.
+ */
+export declare const InlineTransportSchema: GenMessage<InlineTransport>;
+/**
+ * @generated from message jammi.v1.gang.NcclTransport
+ */
+export type NcclTransport = Message<"jammi.v1.gang.NcclTransport"> & {
+    /**
+     * The communicator id the coordinator minted (`ncclGetUniqueId`, 128
+     * bytes): the capability to join this gang's communicator.
+     *
+     * @generated from field: bytes id = 1;
+     */
+    id: Uint8Array;
+};
+/**
+ * Describes the message jammi.v1.gang.NcclTransport.
+ * Use `create(NcclTransportSchema)` to create a new message.
+ */
+export declare const NcclTransportSchema: GenMessage<NcclTransport>;
+/**
+ * The job coordinates only. No training-set identity (resolved by the
+ * handler from the `jobs` row) and no lease duration (the rank derives its
+ * own admission window from the same row). A second `Assign` on an
+ * already-admitted stream is a protocol violation.
+ *
+ * @generated from message jammi.v1.gang.Assign
+ */
+export type Assign = Message<"jammi.v1.gang.Assign"> & {
+    /**
+     * @generated from field: string job_id = 1;
+     */
+    jobId: string;
+    /**
+     * @generated from field: int64 attempt = 2;
+     */
+    attempt: bigint;
+    /**
+     * @generated from field: uint32 rank = 3;
+     */
+    rank: number;
+    /**
+     * @generated from field: uint32 world = 4;
+     */
+    world: number;
+    /**
+     * @generated from field: string coordinator_instance_id = 5;
+     */
+    coordinatorInstanceId: string;
+};
+/**
+ * Describes the message jammi.v1.gang.Assign.
+ * Use `create(AssignSchema)` to create a new message.
+ */
+export declare const AssignSchema: GenMessage<Assign>;
+/**
+ * End this rank's own session cooperatively.
+ *
+ * @generated from message jammi.v1.gang.Cancel
+ */
+export type Cancel = Message<"jammi.v1.gang.Cancel"> & {};
+/**
+ * Describes the message jammi.v1.gang.Cancel.
+ * Use `create(CancelSchema)` to create a new message.
+ */
+export declare const CancelSchema: GenMessage<Cancel>;
+/**
+ * An event frame on a `RunRank` stream.
+ *
+ * @generated from message jammi.v1.gang.RankEvent
+ */
+export type RankEvent = Message<"jammi.v1.gang.RankEvent"> & {
+    /**
+     * @generated from oneof jammi.v1.gang.RankEvent.event
+     */
+    event: {
+        /**
+         * @generated from field: jammi.v1.gang.Admitted admitted = 1;
+         */
+        value: Admitted;
+        case: "admitted";
+    } | {
+        /**
+         * @generated from field: jammi.v1.gang.Aborted aborted = 2;
+         */
+        value: Aborted;
+        case: "aborted";
+    } | {
+        /**
+         * @generated from field: jammi.v1.gang.Outcome outcome = 3;
+         */
+        value: Outcome;
+        case: "outcome";
+    } | {
+        /**
+         * The round protocol, member → coordinator (all after `Admitted`).
+         * This member's contribution to round `round`, followed by
+         * `chunk_count` `round_chunk` frames carrying its Arrow IPC bytes.
+         *
+         * @generated from field: jammi.v1.gang.RoundPayload round_contribution = 4;
+         */
+        value: RoundPayload;
+        case: "roundContribution";
+    } | {
+        /**
+         * @generated from field: jammi.v1.gang.RoundChunk round_chunk = 5;
+         */
+        value: RoundChunk;
+        case: "roundChunk";
+    } | {
+        /**
+         * This member holds the coordinator's result for `round`, decoded and
+         * UNAPPLIED, and will apply it on `RoundCommit`.
+         *
+         * @generated from field: jammi.v1.gang.RoundAck round_ack = 6;
+         */
+        value: RoundAck;
+        case: "roundAck";
+    } | {
+        /**
+         * This member abandons the round; `detail` is why.
+         *
+         * @generated from field: jammi.v1.gang.RoundFault round_fault = 7;
+         */
+        value: RoundFault;
+        case: "roundFault";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message jammi.v1.gang.RankEvent.
+ * Use `create(RankEventSchema)` to create a new message.
+ */
+export declare const RankEventSchema: GenMessage<RankEvent>;
+/**
+ * The rank was admitted: held under re-verification until it ends `Aborted`.
+ *
+ * @generated from message jammi.v1.gang.Admitted
+ */
+export type Admitted = Message<"jammi.v1.gang.Admitted"> & {
+    /**
+     * This member can move its round bytes by an NCCL transport: a CUDA build,
+     * a CUDA device, and a `[worker] collective` other than "cpu". The
+     * coordinator chooses NCCL for the gang only when every rank can.
+     *
+     * @generated from field: bool nccl = 1;
+     */
+    nccl: boolean;
+};
+/**
+ * Describes the message jammi.v1.gang.Admitted.
+ * Use `create(AdmittedSchema)` to create a new message.
+ */
+export declare const AdmittedSchema: GenMessage<Admitted>;
+/**
+ * @generated from message jammi.v1.gang.Aborted
+ */
+export type Aborted = Message<"jammi.v1.gang.Aborted"> & {
+    /**
+     * @generated from field: jammi.v1.gang.AbortReason reason = 1;
+     */
+    reason: AbortReason;
+};
+/**
+ * Describes the message jammi.v1.gang.Aborted.
+ * Use `create(AbortedSchema)` to create a new message.
+ */
+export declare const AbortedSchema: GenMessage<Aborted>;
+/**
+ * The terminal outcome of a rank body's natural end. Frozen here (additive,
+ * costs nothing at the freeze gate — `api_freeze.rs` decodes only
+ * `PACKAGE`/`RPC` tokens) though this rpc's own admission stage ships neither
+ * this variant's producer (a rank body) nor its consumer (the coordinator's
+ * terminal write on receipt).
+ *
+ * @generated from message jammi.v1.gang.Outcome
+ */
+export type Outcome = Message<"jammi.v1.gang.Outcome"> & {
+    /**
+     * @generated from oneof jammi.v1.gang.Outcome.result
+     */
+    result: {
+        /**
+         * @generated from field: jammi.v1.gang.TrainedOutcome trained = 1;
+         */
+        value: TrainedOutcome;
+        case: "trained";
+    } | {
+        /**
+         * @generated from field: jammi.v1.gang.FailedOutcome failed = 2;
+         */
+        value: FailedOutcome;
+        case: "failed";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message jammi.v1.gang.Outcome.
+ * Use `create(OutcomeSchema)` to create a new message.
+ */
+export declare const OutcomeSchema: GenMessage<Outcome>;
+/**
+ * @generated from message jammi.v1.gang.TrainedOutcome
+ */
+export type TrainedOutcome = Message<"jammi.v1.gang.TrainedOutcome"> & {
+    /**
+     * @generated from field: string artifact_digest = 1;
+     */
+    artifactDigest: string;
+};
+/**
+ * Describes the message jammi.v1.gang.TrainedOutcome.
+ * Use `create(TrainedOutcomeSchema)` to create a new message.
+ */
+export declare const TrainedOutcomeSchema: GenMessage<TrainedOutcome>;
+/**
+ * @generated from message jammi.v1.gang.FailedOutcome
+ */
+export type FailedOutcome = Message<"jammi.v1.gang.FailedOutcome"> & {
+    /**
+     * @generated from field: string reason = 1;
+     */
+    reason: string;
+};
+/**
+ * Describes the message jammi.v1.gang.FailedOutcome.
+ * Use `create(FailedOutcomeSchema)` to create a new message.
+ */
+export declare const FailedOutcomeSchema: GenMessage<FailedOutcome>;
+/**
+ * `all_gather`'s per-rank row counts, wrapped so `RoundDescriptor.counts`
+ * distinguishes "this verb carries no counts" (absent) from "every rank
+ * contributes zero rows" (present, all zero).
+ *
+ * @generated from message jammi.v1.gang.Counts
+ */
+export type Counts = Message<"jammi.v1.gang.Counts"> & {
+    /**
+     * @generated from field: repeated uint64 values = 1;
+     */
+    values: bigint[];
+};
+/**
+ * Describes the message jammi.v1.gang.Counts.
+ * Use `create(CountsSchema)` to create a new message.
+ */
+export declare const CountsSchema: GenMessage<Counts>;
+/**
+ * One tensor's shape and element type as far as a round's descriptor cares:
+ * the full shape for `all_reduce_sum` and `broadcast`; the TRAILING shape
+ * (dim 0 dropped) for `all_gather`, whose dim 0 is already `counts`.
+ *
+ * @generated from message jammi.v1.gang.TensorSignature
+ */
+export type TensorSignature = Message<"jammi.v1.gang.TensorSignature"> & {
+    /**
+     * @generated from field: repeated uint64 dims = 1;
+     */
+    dims: bigint[];
+    /**
+     * @generated from field: jammi.v1.gang.ElementType dtype = 2;
+     */
+    dtype: ElementType;
+};
+/**
+ * Describes the message jammi.v1.gang.TensorSignature.
+ * Use `create(TensorSignatureSchema)` to create a new message.
+ */
+export declare const TensorSignatureSchema: GenMessage<TensorSignature>;
+/**
+ * One rank's declaration of what a round computes: the verb, and every
+ * per-call argument other than the tensor bytes that determines the round's
+ * result. The coordinator publishes a round ONLY once every rank's
+ * descriptor equals its own; a disagreement is a typed refusal on EVERY
+ * rank naming both descriptors, symmetric with the in-process collective.
+ *
+ * @generated from message jammi.v1.gang.RoundDescriptor
+ */
+export type RoundDescriptor = Message<"jammi.v1.gang.RoundDescriptor"> & {
+    /**
+     * The round this rank is entering, counted from 0 on every rank. Agreed
+     * like every other field: a contribution from a stale round is a typed
+     * disagreement naming both descriptors, never folded.
+     *
+     * @generated from field: uint64 round = 7;
+     */
+    round: bigint;
+    /**
+     * @generated from field: jammi.v1.gang.RoundVerb verb = 1;
+     */
+    verb: RoundVerb;
+    /**
+     * @generated from field: uint32 world = 2;
+     */
+    world: number;
+    /**
+     * `broadcast`'s root; absent for every other verb.
+     *
+     * @generated from field: optional uint32 root = 3;
+     */
+    root?: number | undefined;
+    /**
+     * `all_gather`'s full counts vector; absent for every other verb.
+     *
+     * @generated from field: jammi.v1.gang.Counts counts = 4;
+     */
+    counts?: Counts | undefined;
+    /**
+     * @generated from field: repeated jammi.v1.gang.TensorSignature tensors = 5;
+     */
+    tensors: TensorSignature[];
+    /**
+     * An opaque digest the caller binds on every rank (a trainer binds its
+     * canonical trainable-variable key order); absent when nothing is bound.
+     * Compared like every other field: a rank bound to a different value, or
+     * to none, disagrees.
+     *
+     * @generated from field: optional string agreement = 6;
+     */
+    agreement?: string | undefined;
+};
+/**
+ * Describes the message jammi.v1.gang.RoundDescriptor.
+ * Use `create(RoundDescriptorSchema)` to create a new message.
+ */
+export declare const RoundDescriptorSchema: GenMessage<RoundDescriptor>;
+/**
+ * A contribution (member → coordinator) or a result (coordinator →
+ * member) for round `round`: the descriptor it was computed under, how many
+ * `RoundChunk` frames follow, and — for `all_reduce_max_flags` only, which
+ * carries no tensor — the control word. Every tensor's bytes travel in the
+ * chunks, each at most the listener's `[server.limits] max_message_bytes`.
+ *
+ * @generated from message jammi.v1.gang.RoundPayload
+ */
+export type RoundPayload = Message<"jammi.v1.gang.RoundPayload"> & {
+    /**
+     * @generated from field: uint64 round = 1;
+     */
+    round: bigint;
+    /**
+     * @generated from field: jammi.v1.gang.RoundDescriptor descriptor = 2;
+     */
+    descriptor?: RoundDescriptor | undefined;
+    /**
+     * @generated from field: uint32 chunk_count = 3;
+     */
+    chunkCount: number;
+    /**
+     * @generated from field: uint32 flags = 4;
+     */
+    flags: number;
+};
+/**
+ * Describes the message jammi.v1.gang.RoundPayload.
+ * Use `create(RoundPayloadSchema)` to create a new message.
+ */
+export declare const RoundPayloadSchema: GenMessage<RoundPayload>;
+/**
+ * One slice of a payload's Arrow IPC bytes: chunk `index` of the
+ * `chunk_count` its `RoundPayload` announced, in order.
+ *
+ * @generated from message jammi.v1.gang.RoundChunk
+ */
+export type RoundChunk = Message<"jammi.v1.gang.RoundChunk"> & {
+    /**
+     * @generated from field: uint64 round = 1;
+     */
+    round: bigint;
+    /**
+     * @generated from field: uint32 index = 2;
+     */
+    index: number;
+    /**
+     * @generated from field: bytes ipc = 3;
+     */
+    ipc: Uint8Array;
+};
+/**
+ * Describes the message jammi.v1.gang.RoundChunk.
+ * Use `create(RoundChunkSchema)` to create a new message.
+ */
+export declare const RoundChunkSchema: GenMessage<RoundChunk>;
+/**
+ * A member holds round `round`'s result, decoded and unapplied.
+ *
+ * @generated from message jammi.v1.gang.RoundAck
+ */
+export type RoundAck = Message<"jammi.v1.gang.RoundAck"> & {
+    /**
+     * @generated from field: uint64 round = 1;
+     */
+    round: bigint;
+};
+/**
+ * Describes the message jammi.v1.gang.RoundAck.
+ * Use `create(RoundAckSchema)` to create a new message.
+ */
+export declare const RoundAckSchema: GenMessage<RoundAck>;
+/**
+ * Every member ACKed round `round`: apply it.
+ *
+ * @generated from message jammi.v1.gang.RoundCommit
+ */
+export type RoundCommit = Message<"jammi.v1.gang.RoundCommit"> & {
+    /**
+     * @generated from field: uint64 round = 1;
+     */
+    round: bigint;
+};
+/**
+ * Describes the message jammi.v1.gang.RoundCommit.
+ * Use `create(RoundCommitSchema)` to create a new message.
+ */
+export declare const RoundCommitSchema: GenMessage<RoundCommit>;
+/**
+ * Round `round` is abandoned on every rank; `detail` is the gang's fault,
+ * quoted by every later refusal on the rank that receives it.
+ *
+ * @generated from message jammi.v1.gang.RoundFault
+ */
+export type RoundFault = Message<"jammi.v1.gang.RoundFault"> & {
+    /**
+     * @generated from field: uint64 round = 1;
+     */
+    round: bigint;
+    /**
+     * @generated from field: string detail = 2;
+     */
+    detail: string;
+};
+/**
+ * Describes the message jammi.v1.gang.RoundFault.
+ * Use `create(RoundFaultSchema)` to create a new message.
+ */
+export declare const RoundFaultSchema: GenMessage<RoundFault>;
+/**
+ * Why a session ended without ever handing control to a rank body. Additive:
+ * a later reason joins this set; none already declared is ever renamed or
+ * removed.
+ *
+ * @generated from enum jammi.v1.gang.AbortReason
+ */
+export declare enum AbortReason {
+    /**
+     * @generated from enum value: ABORT_REASON_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * This host is draining — the only host-initiated cut.
+     *
+     * @generated from enum value: ABORT_REASON_DRAIN = 1;
+     */
+    DRAIN = 1,
+    /**
+     * A row fact refuted admission (status, claimant, attempt, lease, or the
+     * training-set identity no longer holds) — assembly-scoped.
+     *
+     * @generated from enum value: ABORT_REASON_REFUTED = 2;
+     */
+    REFUTED = 2,
+    /**
+     * The rank itself sent `Cancel`.
+     *
+     * @generated from enum value: ABORT_REASON_CANCELLED = 3;
+     */
+    CANCELLED = 3,
+    /**
+     * The admitted session reached its park bound with no body to run.
+     *
+     * @generated from enum value: ABORT_REASON_NO_BODY = 4;
+     */
+    NO_BODY = 4,
+    /**
+     * This host's own object store faulted at re-verification — member-scoped,
+     * never counted against the assembly's attempt budget.
+     *
+     * @generated from enum value: ABORT_REASON_STORE_UNAVAILABLE = 5;
+     */
+    STORE_UNAVAILABLE = 5,
+    /**
+     * The catalog did not answer within tolerance — transient, assembly-scoped,
+     * never counted against the assembly's attempt budget.
+     *
+     * @generated from enum value: ABORT_REASON_UNAVAILABLE = 6;
+     */
+    UNAVAILABLE = 6
+}
+/**
+ * Describes the enum jammi.v1.gang.AbortReason.
+ */
+export declare const AbortReasonSchema: GenEnum<AbortReason>;
+/**
+ * The collective a round computes. CLOSED: a reader matches every value
+ * exhaustively, and `ROUND_VERB_UNSPECIFIED` (or any value it does not
+ * know) is refused, never treated as any verb.
+ *
+ * @generated from enum jammi.v1.gang.RoundVerb
+ */
+export declare enum RoundVerb {
+    /**
+     * @generated from enum value: ROUND_VERB_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: ROUND_VERB_ALL_GATHER = 1;
+     */
+    ALL_GATHER = 1,
+    /**
+     * @generated from enum value: ROUND_VERB_ALL_REDUCE_SUM = 2;
+     */
+    ALL_REDUCE_SUM = 2,
+    /**
+     * @generated from enum value: ROUND_VERB_ALL_REDUCE_MAX_FLAGS = 3;
+     */
+    ALL_REDUCE_MAX_FLAGS = 3,
+    /**
+     * @generated from enum value: ROUND_VERB_BROADCAST = 4;
+     */
+    BROADCAST = 4,
+    /**
+     * @generated from enum value: ROUND_VERB_BARRIER = 5;
+     */
+    BARRIER = 5
+}
+/**
+ * Describes the enum jammi.v1.gang.RoundVerb.
+ */
+export declare const RoundVerbSchema: GenEnum<RoundVerb>;
+/**
+ * The element type of one tensor a round carries. The `Peer` collective
+ * carries exactly these three; every other element type is refused at the
+ * seam before a descriptor is ever built.
+ *
+ * @generated from enum jammi.v1.gang.ElementType
+ */
+export declare enum ElementType {
+    /**
+     * @generated from enum value: ELEMENT_TYPE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: ELEMENT_TYPE_F32 = 1;
+     */
+    F32 = 1,
+    /**
+     * @generated from enum value: ELEMENT_TYPE_F16 = 2;
+     */
+    F16 = 2,
+    /**
+     * @generated from enum value: ELEMENT_TYPE_BF16 = 3;
+     */
+    BF16 = 3
+}
+/**
+ * Describes the enum jammi.v1.gang.ElementType.
+ */
+export declare const ElementTypeSchema: GenEnum<ElementType>;
+/**
+ * GangService — the coordinator-to-member admission wire for a multi-host
+ * gang run. One rpc, `RunRank`, bidi: a member opens the stream and sends
+ * exactly one `Assign` naming its job coordinates (never training-set
+ * identity, which lives on the `jobs` row and is resolved host-side, never
+ * carried on the wire); the handler admits or refuses it, and an admitted
+ * session is HELD under re-verification until it ends `Aborted{reason}`.
+ *
+ * No `FetchPartition`: a rank reads its partition from the shared object
+ * store using the row's own recorded training-set identity — peer-local,
+ * never a wire fetch of bytes every member can already read.
+ *
+ * The ROUND PROTOCOL between admitted ranks rides the same stream, after
+ * `Admitted`, as the `round_*` arms of both frames (see "The round protocol"
+ * below): a member's contribution flows member → coordinator on `RankEvent`,
+ * the coordinator's rank-ordered fold flows coordinator → member on
+ * `RankControl`, and a round applies on a rank only after `RoundCommit`,
+ * which the coordinator sends only after every member's `RoundAck`.
+ *
+ * Served ONLY on the internal `[server] peer_bind` listener, beside
+ * `PeerService` — never on the public gRPC + Flight SQL listener (which
+ * answers UNIMPLEMENTED for these paths), never wrapped by the tenant-binding
+ * layer. Invariant I-GANG: a caller-supplied tenant is never read; the
+ * member derives the tenant from the verified `jobs` row and resolves a
+ * multi-host job's training set under that tenant alone.
+ *
+ * Message shape and arity are frozen by review, not by the api-freeze
+ * guard: that guard decodes only the `PACKAGE`/`(Service, Method)` tokens.
+ * A later change MAY add fields or oneof variants but MUST NOT rename or
+ * remove anything declared here.
+ *
+ * @generated from service jammi.v1.gang.GangService
+ */
+export declare const GangService: GenService<{
+    /**
+     * @generated from rpc jammi.v1.gang.GangService.RunRank
+     */
+    runRank: {
+        methodKind: "bidi_streaming";
+        input: typeof RankControlSchema;
+        output: typeof RankEventSchema;
+    };
+}>;
+//# sourceMappingURL=gang_pb.d.ts.map