@githolon/runtime 0.114.0 → 0.115.0

package/src/protocol/nomos/runtime/v2/correspondence_desk_pb.d.ts

@@ -1493,6 +1493,12 @@ export declare type PeerEffectReceipt = Message<"nomos.runtime.v2.PeerEffectRece
      */
     value: PeerConsoleEnrolmentRefused;
     case: "consoleEnrolmentRefused";
+  } | {
+    /**
+     * @generated from field: nomos.runtime.v2.PeerStreamReceipt stream = 25;
+     */
+    value: PeerStreamReceipt;
+    case: "stream";
   } | { case: undefined; value?: undefined };
 };
 
@@ -1546,6 +1552,14 @@ export declare type PeerGitFetchEffect = Message<"nomos.runtime.v2.PeerGitFetchE
    * @generated from field: nomos.runtime.v2.PeerHttpEffect alongside = 7;
    */
   alongside?: PeerHttpEffect | undefined;
+
+  /**
+   * Independent refs fetched CONCURRENTLY with `reference`, from the same ref advertisement (a
+   * source's settled workspace-effect outcomes). Their failure never fails the fetch.
+   *
+   * @generated from field: nomos.runtime.v2.PeerGitRefsAlongside alongside_refs = 8;
+   */
+  alongsideRefs?: PeerGitRefsAlongside | undefined;
 };
 
 /**
@@ -1587,6 +1601,13 @@ export declare type PeerGitFetchResponse = Message<"nomos.runtime.v2.PeerGitFetc
    * @generated from field: nomos.runtime.v2.PeerHttpResponse alongside = 5;
    */
   alongside?: PeerHttpResponse | undefined;
+
+  /**
+   * The answer to the effect's `alongside_refs`; absent when there was none or it failed.
+   *
+   * @generated from field: nomos.runtime.v2.PeerGitRefsFetched alongside_refs = 6;
+   */
+  alongsideRefs?: PeerGitRefsFetched | undefined;
 };
 
 /**
@@ -1948,6 +1969,12 @@ export declare type CorrespondencePending = Message<"nomos.runtime.v2.Correspond
      */
     value: PeerConsoleEnrolmentEffect;
     case: "consoleEnrolment";
+  } | {
+    /**
+     * @generated from field: nomos.runtime.v2.PeerStreamEffect stream = 15;
+     */
+    value: PeerStreamEffect;
+    case: "stream";
   } | { case: undefined; value?: undefined };
 };
 
@@ -2879,6 +2906,53 @@ export declare type LiveOfferFrame = Message<"nomos.runtime.v2.LiveOfferFrame">
      */
     value: LiveAdmission;
     case: "admission";
+  } | {
+    /**
+     * THE STREAM (architecture/peer_catchup.md, CAP-826). One socket per workspace, to that
+     * workspace's coordinator, carries the workspace's whole lifecycle in order from the cloud
+     * peer that holds it: a checkpoint at head H (chunked, resumable), the offers after H in
+     * bounded batches, then live offers. A device never contacts Artifacts.
+     *
+     * @generated from field: nomos.runtime.v2.LiveCheckpointRequest checkpoint_request = 4;
+     */
+    value: LiveCheckpointRequest;
+    case: "checkpointRequest";
+  } | {
+    /**
+     * @generated from field: nomos.runtime.v2.LiveCheckpointOffer checkpoint_offer = 5;
+     */
+    value: LiveCheckpointOffer;
+    case: "checkpointOffer";
+  } | {
+    /**
+     * @generated from field: nomos.runtime.v2.LiveCheckpointChunk checkpoint_chunk = 6;
+     */
+    value: LiveCheckpointChunk;
+    case: "checkpointChunk";
+  } | {
+    /**
+     * @generated from field: nomos.runtime.v2.LiveHistoryRequest history_request = 7;
+     */
+    value: LiveHistoryRequest;
+    case: "historyRequest";
+  } | {
+    /**
+     * @generated from field: nomos.runtime.v2.LiveRefRequest ref_request = 8;
+     */
+    value: LiveRefRequest;
+    case: "refRequest";
+  } | {
+    /**
+     * @generated from field: nomos.runtime.v2.LivePack pack = 9;
+     */
+    value: LivePack;
+    case: "pack";
+  } | {
+    /**
+     * @generated from field: nomos.runtime.v2.LiveStreamRefusal refusal = 10;
+     */
+    value: LiveStreamRefusal;
+    case: "refusal";
   } | { case: undefined; value?: undefined };
 };
 
@@ -2914,6 +2988,14 @@ export declare type LiveAdmission = Message<"nomos.runtime.v2.LiveAdmission"> &
 export declare const LiveAdmissionSchema: GenMessage<LiveAdmission>;
 
 /**
+ * `max_offers` (a stream-capable receiver): send at most this many offers directly above `head`;
+ * the receiver announces its new head once it admitted them, and the next batch follows.
+ * `remount_after_offers`: sent only by a copy holding no work above its bookmark. Further behind
+ * than this many offers, or at a head the peer does not hold, answer a checkpoint_offer instead.
+ * `outcomes_digest` (a stream-capable receiver): the hex sha256 of the sorted object ids of the
+ * settled-letter outcome refs it holds (#567). A peer whose own set differs answers with its
+ * `outcomes` (names and ids only); the receiver asks for the ones it lacks with a ref request.
+ *
  * @generated from message nomos.runtime.v2.LiveFrontier
  */
 export declare type LiveFrontier = Message<"nomos.runtime.v2.LiveFrontier"> & {
@@ -2926,6 +3008,33 @@ export declare type LiveFrontier = Message<"nomos.runtime.v2.LiveFrontier"> & {
    * @generated from field: bool response = 2;
    */
   response: boolean;
+
+  /**
+   * @generated from field: uint32 max_offers = 3;
+   */
+  maxOffers: number;
+
+  /**
+   * @generated from field: uint32 remount_after_offers = 4;
+   */
+  remountAfterOffers: number;
+
+  /**
+   * @generated from field: string outcomes_digest = 5;
+   */
+  outcomesDigest: string;
+
+  /**
+   * @generated from field: repeated nomos.runtime.v2.RetainedRef outcomes = 6;
+   */
+  outcomes: RetainedRef[];
+
+  /**
+   * In a peer's answer: the main its custodian has made durable (a copy bookmarks only that).
+   *
+   * @generated from field: optional string sealed = 7;
+   */
+  sealed?: string | undefined;
 };
 
 /**
@@ -2934,6 +3043,540 @@ export declare type LiveFrontier = Message<"nomos.runtime.v2.LiveFrontier"> & {
  */
 export declare const LiveFrontierSchema: GenMessage<LiveFrontier>;
 
+/**
+ * Start or resume a checkpoint. A resume names the checkpoint (`head`, `pack_id`) and the bytes it
+ * already holds (`offset`); the peer answers the next `window_chunks` chunks, or a newer offer.
+ * `pack_id` is the pack's own trailer hash (hex SHA-1 of its bytes): the receiving kernel verifies it
+ * while indexing, so no shell hashes a checkpoint in JavaScript.
+ *
+ * @generated from message nomos.runtime.v2.LiveCheckpointRequest
+ */
+export declare type LiveCheckpointRequest = Message<"nomos.runtime.v2.LiveCheckpointRequest"> & {
+  /**
+   * @generated from field: optional string head = 1;
+   */
+  head?: string | undefined;
+
+  /**
+   * @generated from field: optional string pack_id = 2;
+   */
+  packId?: string | undefined;
+
+  /**
+   * @generated from field: uint64 offset = 3;
+   */
+  offset: bigint;
+
+  /**
+   * @generated from field: uint32 window_chunks = 4;
+   */
+  windowChunks: number;
+};
+
+/**
+ * Describes the message nomos.runtime.v2.LiveCheckpointRequest.
+ * Use `create(LiveCheckpointRequestSchema)` to create a new message.
+ */
+export declare const LiveCheckpointRequestSchema: GenMessage<LiveCheckpointRequest>;
+
+/**
+ * The checkpoint the peer will send: the frontier state at H (H's commit and state tree, and the
+ * settled-letter outcome commits beside it), one deterministic Git pack. It is the same shape as an
+ * epoch boundary's frontier state (CAP-825), whether or not epochs are on.
+ *
+ * @generated from message nomos.runtime.v2.LiveCheckpointOffer
+ */
+export declare type LiveCheckpointOffer = Message<"nomos.runtime.v2.LiveCheckpointOffer"> & {
+  /**
+   * @generated from field: string head = 1;
+   */
+  head: string;
+
+  /**
+   * @generated from field: string pack_id = 2;
+   */
+  packId: string;
+
+  /**
+   * @generated from field: uint64 bytes = 3;
+   */
+  bytes: bigint;
+
+  /**
+   * @generated from field: uint32 chunk_bytes = 4;
+   */
+  chunkBytes: number;
+
+  /**
+   * @generated from field: repeated string shallow = 6;
+   */
+  shallow: string[];
+
+  /**
+   * The settled-letter outcome refs whose commits the pack carries (#567).
+   *
+   * @generated from field: repeated nomos.runtime.v2.RetainedRef outcomes = 7;
+   */
+  outcomes: RetainedRef[];
+
+  /**
+   * Offered instead of offers: the copy is further behind than its remount bound, or its head is
+   * not in the peer's custody.
+   *
+   * @generated from field: bool remount = 8;
+   */
+  remount: boolean;
+
+  /**
+   * @generated from field: optional uint64 offers_behind = 9;
+   */
+  offersBehind?: bigint | undefined;
+
+  /**
+   * Set when this transfer is a history slice, not a checkpoint: the slice's request id. `head` is
+   * then the shallow boundary the slice continues below, `shallow` its new boundary.
+   *
+   * @generated from field: string request_id = 10;
+   */
+  requestId: string;
+
+  /**
+   * The main this peer's custodian has made durable. A checkpoint is offered at it whenever the peer
+   * knows it and it is on main; the offers above it follow in batches, so a stream never waits for a
+   * seal. A copy bookmarks the checkpoint's head only when it is this sealed head.
+   *
+   * @generated from field: optional string sealed = 11;
+   */
+  sealed?: string | undefined;
+
+  /**
+   * The peer's main when it offered this checkpoint. Above `head`, the copy levels to it after mounting.
+   *
+   * @generated from field: string main = 12;
+   */
+  main: string;
+};
+
+/**
+ * Describes the message nomos.runtime.v2.LiveCheckpointOffer.
+ * Use `create(LiveCheckpointOfferSchema)` to create a new message.
+ */
+export declare const LiveCheckpointOfferSchema: GenMessage<LiveCheckpointOffer>;
+
+/**
+ * One chunk of a checkpoint, or (with `request_id`) of a history slice.
+ *
+ * @generated from message nomos.runtime.v2.LiveCheckpointChunk
+ */
+export declare type LiveCheckpointChunk = Message<"nomos.runtime.v2.LiveCheckpointChunk"> & {
+  /**
+   * @generated from field: string pack_id = 1;
+   */
+  packId: string;
+
+  /**
+   * @generated from field: uint64 offset = 2;
+   */
+  offset: bigint;
+
+  /**
+   * @generated from field: bytes bytes = 3;
+   */
+  bytes: Uint8Array;
+
+  /**
+   * @generated from field: string request_id = 4;
+   */
+  requestId: string;
+};
+
+/**
+ * Describes the message nomos.runtime.v2.LiveCheckpointChunk.
+ * Use `create(LiveCheckpointChunkSchema)` to create a new message.
+ */
+export declare const LiveCheckpointChunkSchema: GenMessage<LiveCheckpointChunk>;
+
+/**
+ * One lazy-history slice: `depth` generations below a shallow `boundary` the copy holds. A slice is a
+ * transfer like a checkpoint: offered, then chunked; a resume names the slice (`pack_id`) and the bytes
+ * already held (`offset`), and the peer answers the next `window_chunks` chunks.
+ *
+ * @generated from message nomos.runtime.v2.LiveHistoryRequest
+ */
+export declare type LiveHistoryRequest = Message<"nomos.runtime.v2.LiveHistoryRequest"> & {
+  /**
+   * @generated from field: string request_id = 1;
+   */
+  requestId: string;
+
+  /**
+   * @generated from field: string boundary = 2;
+   */
+  boundary: string;
+
+  /**
+   * @generated from field: uint32 depth = 3;
+   */
+  depth: number;
+
+  /**
+   * @generated from field: optional string pack_id = 4;
+   */
+  packId?: string | undefined;
+
+  /**
+   * @generated from field: uint64 offset = 5;
+   */
+  offset: bigint;
+
+  /**
+   * @generated from field: uint32 window_chunks = 6;
+   */
+  windowChunks: number;
+};
+
+/**
+ * Describes the message nomos.runtime.v2.LiveHistoryRequest.
+ * Use `create(LiveHistoryRequestSchema)` to create a new message.
+ */
+export declare const LiveHistoryRequestSchema: GenMessage<LiveHistoryRequest>;
+
+/**
+ * An independent ref (refs/nomos/placement) at `want`, with its (small) history; or, for the
+ * settled-letter outcome namespace (refs/nomos/effect-outcomes/), the parentless commits `wants`.
+ *
+ * @generated from message nomos.runtime.v2.LiveRefRequest
+ */
+export declare type LiveRefRequest = Message<"nomos.runtime.v2.LiveRefRequest"> & {
+  /**
+   * @generated from field: string request_id = 1;
+   */
+  requestId: string;
+
+  /**
+   * @generated from field: string reference = 2;
+   */
+  reference: string;
+
+  /**
+   * @generated from field: optional string want = 3;
+   */
+  want?: string | undefined;
+
+  /**
+   * @generated from field: repeated string wants = 4;
+   */
+  wants: string[];
+};
+
+/**
+ * Describes the message nomos.runtime.v2.LiveRefRequest.
+ * Use `create(LiveRefRequestSchema)` to create a new message.
+ */
+export declare const LiveRefRequestSchema: GenMessage<LiveRefRequest>;
+
+/**
+ * A pack the stream sends: a checkpoint, a history slice, a ref, settled-letter outcomes, or a batch
+ * of the offers after a copy's head (`request_id` "level:<base>", `base` the head it continues): the
+ * sealed offers as the commits the peer admitted them in, so the copy's kernel adopts exactly those
+ * commits on the same parent and verifies them by hash.
+ *
+ * @generated from message nomos.runtime.v2.LivePack
+ */
+export declare type LivePack = Message<"nomos.runtime.v2.LivePack"> & {
+  /**
+   * @generated from field: string request_id = 1;
+   */
+  requestId: string;
+
+  /**
+   * @generated from field: string reference = 2;
+   */
+  reference: string;
+
+  /**
+   * @generated from field: string head = 3;
+   */
+  head: string;
+
+  /**
+   * @generated from field: bytes pack = 4;
+   */
+  pack: Uint8Array;
+
+  /**
+   * @generated from field: repeated string shallow = 5;
+   */
+  shallow: string[];
+
+  /**
+   * @generated from field: string base = 6;
+   */
+  base: string;
+
+  /**
+   * @generated from field: uint32 offers = 7;
+   */
+  offers: number;
+
+  /**
+   * The main the peer's custodian had made durable when it answered.
+   *
+   * @generated from field: optional string sealed = 8;
+   */
+  sealed?: string | undefined;
+};
+
+/**
+ * Describes the message nomos.runtime.v2.LivePack.
+ * Use `create(LivePackSchema)` to create a new message.
+ */
+export declare const LivePackSchema: GenMessage<LivePack>;
+
+/**
+ * @generated from message nomos.runtime.v2.LiveStreamRefusal
+ */
+export declare type LiveStreamRefusal = Message<"nomos.runtime.v2.LiveStreamRefusal"> & {
+  /**
+   * @generated from field: string request_id = 1;
+   */
+  requestId: string;
+
+  /**
+   * @generated from field: string code = 2;
+   */
+  code: string;
+
+  /**
+   * @generated from field: string message = 3;
+   */
+  message: string;
+
+  /**
+   * The peer is opening the workspace or acquiring the history asked for: ask again after this.
+   *
+   * @generated from field: optional uint32 retry_after_millis = 4;
+   */
+  retryAfterMillis?: number | undefined;
+};
+
+/**
+ * Describes the message nomos.runtime.v2.LiveStreamRefusal.
+ * Use `create(LiveStreamRefusalSchema)` to create a new message.
+ */
+export declare const LiveStreamRefusalSchema: GenMessage<LiveStreamRefusal>;
+
+/**
+ * A coordinator's paper to the cloud peer that holds the workspace: serve one stream request.
+ *
+ * @generated from message nomos.runtime.v2.LiveStreamRequest
+ */
+export declare type LiveStreamRequest = Message<"nomos.runtime.v2.LiveStreamRequest"> & {
+  /**
+   * @generated from oneof nomos.runtime.v2.LiveStreamRequest.request
+   */
+  request: {
+    /**
+     * @generated from field: nomos.runtime.v2.LiveFrontier frontier = 1;
+     */
+    value: LiveFrontier;
+    case: "frontier";
+  } | {
+    /**
+     * @generated from field: nomos.runtime.v2.LiveCheckpointRequest checkpoint = 2;
+     */
+    value: LiveCheckpointRequest;
+    case: "checkpoint";
+  } | {
+    /**
+     * @generated from field: nomos.runtime.v2.LiveHistoryRequest history = 3;
+     */
+    value: LiveHistoryRequest;
+    case: "history";
+  } | {
+    /**
+     * @generated from field: nomos.runtime.v2.LiveRefRequest ref = 4;
+     */
+    value: LiveRefRequest;
+    case: "ref";
+  } | { case: undefined; value?: undefined };
+};
+
+/**
+ * Describes the message nomos.runtime.v2.LiveStreamRequest.
+ * Use `create(LiveStreamRequestSchema)` to create a new message.
+ */
+export declare const LiveStreamRequestSchema: GenMessage<LiveStreamRequest>;
+
+/**
+ * The frames to send, in order, to the socket that asked.
+ *
+ * @generated from message nomos.runtime.v2.LiveStreamAnswer
+ */
+export declare type LiveStreamAnswer = Message<"nomos.runtime.v2.LiveStreamAnswer"> & {
+  /**
+   * @generated from field: repeated nomos.runtime.v2.LiveOfferFrame frames = 1;
+   */
+  frames: LiveOfferFrame[];
+};
+
+/**
+ * Describes the message nomos.runtime.v2.LiveStreamAnswer.
+ * Use `create(LiveStreamAnswerSchema)` to create a new message.
+ */
+export declare const LiveStreamAnswerSchema: GenMessage<LiveStreamAnswer>;
+
+/**
+ * Inside a device's Peer Office only (architecture/peer_catchup.md): a procedure's request of its
+ * workspace's stream. The office serves it over the workspace's live socket and answers the
+ * procedure itself; a shell never performs it and refuses one it is handed.
+ *
+ * @generated from message nomos.runtime.v2.PeerStreamEffect
+ */
+export declare type PeerStreamEffect = Message<"nomos.runtime.v2.PeerStreamEffect"> & {
+  /**
+   * @generated from field: string effect_id = 1;
+   */
+  effectId: string;
+
+  /**
+   * @generated from field: string workspace = 2;
+   */
+  workspace: string;
+
+  /**
+   * @generated from oneof nomos.runtime.v2.PeerStreamEffect.request
+   */
+  request: {
+    /**
+     * @generated from field: nomos.runtime.v2.LiveCheckpointRequest checkpoint = 3;
+     */
+    value: LiveCheckpointRequest;
+    case: "checkpoint";
+  } | {
+    /**
+     * @generated from field: nomos.runtime.v2.LiveHistoryRequest history = 4;
+     */
+    value: LiveHistoryRequest;
+    case: "history";
+  } | {
+    /**
+     * @generated from field: nomos.runtime.v2.LiveRefRequest ref = 5;
+     */
+    value: LiveRefRequest;
+    case: "ref";
+  } | {
+    /**
+     * Bring this copy level with the peer's main over the socket: batches of offers after its head,
+     * or (with `remount_after_offers`, from a copy holding no work above its bookmark) a checkpoint
+     * to remount when it is further behind than that.
+     *
+     * @generated from field: nomos.runtime.v2.LiveFrontier level = 6;
+     */
+    value: LiveFrontier;
+    case: "level";
+  } | { case: undefined; value?: undefined };
+
+  /**
+   * Only start the ask and answer at once (an empty receipt): the procedure does other work (its
+   * law products) while the stream delivers, then asks again without `start_only` to wait for it.
+   *
+   * @generated from field: bool start_only = 7;
+   */
+  startOnly: boolean;
+
+  /**
+   * Where the workspace is followed from (its custodian's workspace URL) and the credential the
+   * stream presents, for a workspace this copy streams without a follow of its own (a prerequisite).
+   *
+   * @generated from field: string upstream = 8;
+   */
+  upstream: string;
+
+  /**
+   * @generated from field: string credential_capability = 9;
+   */
+  credentialCapability: string;
+};
+
+/**
+ * Describes the message nomos.runtime.v2.PeerStreamEffect.
+ * Use `create(PeerStreamEffectSchema)` to create a new message.
+ */
+export declare const PeerStreamEffectSchema: GenMessage<PeerStreamEffect>;
+
+/**
+ * @generated from message nomos.runtime.v2.PeerStreamReceipt
+ */
+export declare type PeerStreamReceipt = Message<"nomos.runtime.v2.PeerStreamReceipt"> & {
+  /**
+   * @generated from oneof nomos.runtime.v2.PeerStreamReceipt.outcome
+   */
+  outcome: {
+    /**
+     * A complete, verified checkpoint, or the pack a history/ref request asked for.
+     *
+     * @generated from field: nomos.runtime.v2.LivePack pack = 1;
+     */
+    value: LivePack;
+    case: "pack";
+  } | {
+    /**
+     * The stream brought this copy's main to the peer's announced main.
+     *
+     * @generated from field: string level = 2;
+     */
+    value: string;
+    case: "level";
+  } | {
+    /**
+     * @generated from field: nomos.runtime.v2.LiveStreamRefusal refusal = 3;
+     */
+    value: LiveStreamRefusal;
+    case: "refusal";
+  } | { case: undefined; value?: undefined };
+
+  /**
+   * The checkpoint's outcome refs, present with a checkpoint pack.
+   *
+   * @generated from field: repeated nomos.runtime.v2.RetainedRef outcomes = 4;
+   */
+  outcomes: RetainedRef[];
+
+  /**
+   * @generated from field: uint64 received_bytes = 5;
+   */
+  receivedBytes: bigint;
+
+  /**
+   * The peer's durable main as it last said (a copy bookmarks only a durable head).
+   *
+   * @generated from field: optional string sealed = 6;
+   */
+  sealed?: string | undefined;
+
+  /**
+   * The pack's bytes are a file in the kernel's filesystem (the transfer landed there chunk by chunk);
+   * the pack field is then empty and the import names this file.
+   *
+   * @generated from field: optional string staged_pack_file = 7;
+   */
+  stagedPackFile?: string | undefined;
+
+  /**
+   * With a checkpoint: the peer's main when it offered it (the copy levels to it after mounting).
+   *
+   * @generated from field: optional string main = 8;
+   */
+  main?: string | undefined;
+};
+
+/**
+ * Describes the message nomos.runtime.v2.PeerStreamReceipt.
+ * Use `create(PeerStreamReceiptSchema)` to create a new message.
+ */
+export declare const PeerStreamReceiptSchema: GenMessage<PeerStreamReceipt>;
+
 /**
  * Runtime-owned socket lifecycle; shells only operate the identified socket.
  *
@@ -3738,6 +4381,67 @@ export declare type OutboxTargetCount = Message<"nomos.runtime.v2.OutboxTargetCo
  */
 export declare const OutboxTargetCountSchema: GenMessage<OutboxTargetCount>;
 
+/**
+ * Every ref the remote advertises below `prefix`, each an independent history of its own (never
+ * below `reference`'s shallow boundary). The shell fetches, without depth and without negotiation,
+ * the advertised objects not in `held`, at most `limit` of them per fetch (0: no limit).
+ *
+ * @generated from message nomos.runtime.v2.PeerGitRefsAlongside
+ */
+export declare type PeerGitRefsAlongside = Message<"nomos.runtime.v2.PeerGitRefsAlongside"> & {
+  /**
+   * @generated from field: string prefix = 1;
+   */
+  prefix: string;
+
+  /**
+   * @generated from field: repeated string held = 2;
+   */
+  held: string[];
+
+  /**
+   * @generated from field: uint32 limit = 3;
+   */
+  limit: number;
+};
+
+/**
+ * Describes the message nomos.runtime.v2.PeerGitRefsAlongside.
+ * Use `create(PeerGitRefsAlongsideSchema)` to create a new message.
+ */
+export declare const PeerGitRefsAlongsideSchema: GenMessage<PeerGitRefsAlongside>;
+
+/**
+ * The advertised refs below the prefix whose objects the peer holds once `pack` is imported: every
+ * one already `held`, and every one this pack carries. The Peer Office chooses which to write.
+ *
+ * @generated from message nomos.runtime.v2.PeerGitRefsFetched
+ */
+export declare type PeerGitRefsFetched = Message<"nomos.runtime.v2.PeerGitRefsFetched"> & {
+  /**
+   * @generated from field: repeated nomos.runtime.v2.RetainedRef refs = 1;
+   */
+  refs: RetainedRef[];
+
+  /**
+   * @generated from field: bytes pack = 2;
+   */
+  pack: Uint8Array;
+
+  /**
+   * Advertised refs below the prefix that this fetch left for a later one (the `limit`).
+   *
+   * @generated from field: uint32 deferred = 3;
+   */
+  deferred: number;
+};
+
+/**
+ * Describes the message nomos.runtime.v2.PeerGitRefsFetched.
+ * Use `create(PeerGitRefsFetchedSchema)` to create a new message.
+ */
+export declare const PeerGitRefsFetchedSchema: GenMessage<PeerGitRefsFetched>;
+
 /**
  * @generated from enum nomos.runtime.v2.ShareWorkspaceOutcome
  */