@defrex/autobuild 0.8.0 → 0.10.0

package/packages/core/src/store/remote/client.ts

@@ -32,9 +32,22 @@ import type {
   SessionEventType,
   SessionEventWrite,
 } from '../../events/sessions'
+import {
+  DEFAULT_TICKET_ASSET_LIMITS,
+  TicketAssetValidationError,
+  validateTicketAssetInput,
+  type TicketAsset,
+  type TicketAssetContentEntry,
+  type TicketAssetInput,
+  type TicketAssetLimits,
+  type TicketAssetMeta,
+  type TicketAssetSummary,
+} from '../ticket-assets'
 import { createBuildScopedStore } from '../build-scope'
 import { createSessionScopedStore } from '../session-handle'
 import { pollingSubscribe } from '../subscribe'
+import type { ReducerSnapshot, SnapshotScope } from '../snapshots'
+import type { BuildDigest } from '../types'
 import type {
   StreamChunk,
   StreamOutcome,
@@ -68,9 +81,11 @@ import {
   artifactGetResponseSchema,
   artifactMetaListSchema,
   artifactMetaWireSchema,
+  buildDigestListSchema,
   buildRecordListSchema,
   buildRecordWireSchema,
   conditionalEventResponseSchema,
+  conditionalSessionEventResponseSchema,
   decodeBase64,
   depositsResponseSchema,
   encodeBase64,
@@ -78,8 +93,11 @@ import {
   eventEnvelopeWireSchema,
   eventListSchema,
   repositoryEventEnvelopeWireSchema,
+  repoHighWaterSchema,
   repositoryEventListSchema,
   okResponseSchema,
+  reducerSnapshotPutResponseSchema,
+  reducerSnapshotResponseSchema,
   placeholderRev,
   repoDepositsResponseSchema,
   repositoryArtifactGetResponseSchema,
@@ -96,6 +114,12 @@ import {
   sessionRecordWireSchema,
   streamChunkWireSchema,
   streamReadWireSchema,
+  ticketAssetFileResponseSchema,
+  ticketAssetLimitsWireSchema,
+  ticketAssetManifestResponseSchema,
+  ticketAssetMetaWireSchema,
+  ticketAssetSummaryListSchema,
+  removeTicketAssetResponseSchema,
   streamRecordListSchema,
   streamRecordWireSchema,
 } from './protocol'
@@ -173,7 +197,7 @@ export class RemoteBuildStore implements BuildStore {
   }
 
   private async raw(
-    method: 'GET' | 'POST',
+    method: 'GET' | 'POST' | 'PUT',
     path: string,
     body?: unknown,
     signal?: AbortSignal,
@@ -187,7 +211,11 @@ export class RemoteBuildStore implements BuildStore {
     return this.fetchFn(`${this.base}${path}`, {
       method,
       headers,
-      ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+      // A string body is already serialized JSON (the ticket-asset put sizes
+      // its exact bytes before sending).
+      ...(body !== undefined
+        ? { body: typeof body === 'string' ? body : JSON.stringify(body) }
+        : {}),
       ...(signal !== undefined ? { signal } : {}),
     })
   }
@@ -205,6 +233,12 @@ export class RemoteBuildStore implements BuildStore {
     }
     // D6: validation feedback crosses the wire as the same error type with
     // the server's message intact.
+    if (
+      (response.status === 422 || response.status === 413) &&
+      message.startsWith('ticket asset')
+    ) {
+      return new TicketAssetValidationError(message)
+    }
     if (response.status === 422) return new EventValidationError(message)
     // Typed stream rejections rehydrate by the server's message shape: the
     // ceiling names its bytes, the closed-append names its stream (a 409 is
@@ -246,6 +280,19 @@ export class RemoteBuildStore implements BuildStore {
     return this.requestJson('GET', '/builds', buildRecordListSchema)
   }
 
+  async getRepoBuildDigests(repo: string): Promise<Map<string, BuildDigest>> {
+    // A repo-scoped batch read (AUT-487): one request regardless of build
+    // count. The route answers from build records, so an unknown repo or a
+    // repo without a journal record answers 200 with an empty array rather
+    // than 404 — the server composes it before the repository-existence gate.
+    const digests = await this.requestJson(
+      'GET',
+      `${this.repoPath(repo)}/build-digests`,
+      buildDigestListSchema,
+    )
+    return new Map(digests.map((digest) => [digest.slug, digest]))
+  }
+
   async append<T extends EventType>(slug: string, event: EventWrite<T>): Promise<EventEnvelope<T>> {
     const envelope = await this.requestJson(
       'POST',
@@ -492,6 +539,64 @@ export class RemoteBuildStore implements BuildStore {
     )
   }
 
+  private snapshotPath(scope: SnapshotScope, reducer: string): string {
+    const root = scope.kind === 'build' ? this.buildPath(scope.slug) : this.repoPath(scope.repo)
+    return `${root}/snapshots/${encodeURIComponent(reducer)}`
+  }
+
+  async getReducerSnapshot(
+    scope: SnapshotScope,
+    reducer: string,
+    version: number,
+  ): Promise<ReducerSnapshot | null> {
+    // Additive routes, no protocol bump. A store that predates them answers
+    // 404 or 405 for the route, which reads as "no snapshot": the caller
+    // replays the log. Auth and transport failures still surface.
+    const response = await this.raw(
+      'GET',
+      `${this.snapshotPath(scope, reducer)}?version=${version}`,
+    )
+    if (response.status === 404 || response.status === 405) return null
+    if (!response.ok) throw await this.toError(response)
+    return reducerSnapshotResponseSchema.parse(await response.json())
+  }
+
+  async putReducerSnapshot(
+    scope: SnapshotScope,
+    reducer: string,
+    snapshot: ReducerSnapshot,
+  ): Promise<boolean> {
+    const response = await this.raw('PUT', this.snapshotPath(scope, reducer), {
+      version: snapshot.version,
+      cursor: snapshot.cursor,
+      state: snapshot.state ?? null,
+    })
+    if (response.status === 404 || response.status === 405) return false
+    if (!response.ok) throw await this.toError(response)
+    return reducerSnapshotPutResponseSchema.parse(await response.json()).written
+  }
+
+  async getRepoHighWater(repo: string): Promise<number> {
+    // Additive route beside `state-events`; the store service and client
+    // ship in version lockstep, so no protocol bump.
+    return this.requestJson('GET', `${this.repoPath(repo)}/high-water`, repoHighWaterSchema).then(
+      (body) => (body as { seq: number }).seq,
+    )
+  }
+
+  async getRepoStateEvents(repo: string): Promise<RepositoryEvent[]> {
+    // The bounded repository-journal read (AUT-489): one additive route next
+    // to `GET events`, reusing the same wire shape. No protocol-version bump
+    // and no change to existing routes — a client on the previous release
+    // never calls this route, so behavioral identity of the old surface is
+    // the whole cross-version contract.
+    return this.requestJson(
+      'GET',
+      `${this.repoPath(repo)}/state-events`,
+      repositoryEventListSchema,
+    ) as Promise<RepositoryEvent[]>
+  }
+
   async putRepoArtifact(repo: string, artifact: ArtifactInput): Promise<RepositoryArtifactMeta> {
     return this.requestJson(
       'POST',
@@ -531,6 +636,192 @@ export class RemoteBuildStore implements BuildStore {
     )
   }
 
+  /** The limits this store handle enforces locally, fetched once per repo
+   * and cached. A server that predates the route (404) gets the defaults. */
+  private readonly assetLimits = new Map<
+    string,
+    Promise<TicketAssetLimits & { maxRequestBytes?: number }>
+  >()
+
+  private assetLimitsFor(repo: string): Promise<TicketAssetLimits & { maxRequestBytes?: number }> {
+    let cached = this.assetLimits.get(repo)
+    if (cached === undefined) {
+      cached = (async () => {
+        const response = await this.raw('GET', `${this.repoPath(repo)}/ticket-asset-limits`)
+        if (response.status === 404) return { ...DEFAULT_TICKET_ASSET_LIMITS }
+        if (!response.ok) throw await this.toError(response)
+        return ticketAssetLimitsWireSchema.parse(await response.json())
+      })()
+      cached.catch(() => this.assetLimits.delete(repo))
+      this.assetLimits.set(repo, cached)
+    }
+    return cached
+  }
+
+  async ticketAssetLimits(repo: string): Promise<TicketAssetLimits> {
+    const { maxBytes, maxEntries } = await this.assetLimitsFor(repo)
+    return { maxBytes, maxEntries }
+  }
+
+  private assetPath(repo: string, ticketId: string): string {
+    return `${this.repoPath(repo)}/tickets/${encodeURIComponent(ticketId)}/assets`
+  }
+
+  async putTicketAsset(
+    repo: string,
+    ticketId: string,
+    asset: TicketAssetInput,
+  ): Promise<TicketAssetMeta> {
+    const limits = await this.assetLimitsFor(repo)
+    try {
+      validateTicketAssetInput(asset, limits)
+    } catch (error) {
+      if (
+        error instanceof TicketAssetValidationError &&
+        limits.maxRequestBytes !== undefined &&
+        /^ticket asset exceeds the \d+-byte/.test(error.message)
+      ) {
+        throw new TicketAssetValidationError(
+          `ticket asset exceeds this store's ${limits.maxBytes}-byte limit (deployment request ceiling ${limits.maxRequestBytes} bytes)`,
+        )
+      }
+      throw error
+    }
+    const text = JSON.stringify({
+      kind: asset.kind,
+      name: asset.name,
+      layout: asset.layout,
+      entries: asset.entries.map((entry) =>
+        entry.type === 'dir'
+          ? { type: 'dir', path: entry.path }
+          : { type: 'file', path: entry.path, contentBase64: encodeBase64(entry.content) },
+      ),
+    })
+    if (limits.maxRequestBytes !== undefined) {
+      const bytes = new TextEncoder().encode(text).length
+      if (bytes > limits.maxRequestBytes) {
+        throw new TicketAssetValidationError(
+          `ticket asset exceeds this store's ${limits.maxBytes}-byte limit (deployment request ceiling ${limits.maxRequestBytes} bytes): the encoded request is ${bytes} bytes`,
+        )
+      }
+    }
+    return this.requestJson('POST', this.assetPath(repo, ticketId), ticketAssetMetaWireSchema, text)
+  }
+
+  async getTicketAsset(
+    repo: string,
+    ticketId: string,
+    kind: string,
+    name: string,
+    rev?: number,
+  ): Promise<TicketAsset | null> {
+    const params = new URLSearchParams({ kind, name })
+    if (rev !== undefined) params.set('rev', String(rev))
+    const meta = await this.requestJson(
+      'GET',
+      `${this.assetPath(repo, ticketId)}?${params}`,
+      ticketAssetManifestResponseSchema,
+    )
+    if (meta === null) return null
+    // One request per file, pinned to the manifest's revision, so no response
+    // carries more than a single file.
+    const entries: TicketAssetContentEntry[] = []
+    for (const entry of meta.entries) {
+      if (entry.type === 'dir') {
+        entries.push({ type: 'dir', path: entry.path })
+        continue
+      }
+      const fileParams = new URLSearchParams({
+        kind,
+        name,
+        rev: String(meta.revision),
+        path: entry.path,
+      })
+      const file = await this.requestJson(
+        'GET',
+        `${this.assetPath(repo, ticketId)}/file?${fileParams}`,
+        ticketAssetFileResponseSchema,
+      )
+      if (file === null) {
+        throw new Error(
+          `ticket asset ${kind}/${name} revision ${meta.revision} vanished mid-download`,
+        )
+      }
+      entries.push({ type: 'file', path: entry.path, content: decodeBase64(file.contentBase64) })
+    }
+    return { meta, entries }
+  }
+
+  async getPinnedTicketAsset(
+    slug: string,
+    kind: string,
+    name: string,
+    rev?: number,
+  ): Promise<TicketAsset | null> {
+    const params = new URLSearchParams({ kind, name })
+    if (rev !== undefined) params.set('rev', String(rev))
+    const meta = await this.requestJson(
+      'GET',
+      `${this.buildPath(slug)}/ticket-assets?${params}`,
+      ticketAssetManifestResponseSchema,
+    )
+    if (meta === null) return null
+    // One request per file, pinned to the manifest's revision, so no response
+    // carries more than a single file.
+    const entries: TicketAssetContentEntry[] = []
+    for (const entry of meta.entries) {
+      if (entry.type === 'dir') {
+        entries.push({ type: 'dir', path: entry.path })
+        continue
+      }
+      const fileParams = new URLSearchParams({
+        kind,
+        name,
+        rev: String(meta.revision),
+        path: entry.path,
+      })
+      const file = await this.requestJson(
+        'GET',
+        `${this.buildPath(slug)}/ticket-assets/file?${fileParams}`,
+        ticketAssetFileResponseSchema,
+      )
+      if (file === null) {
+        throw new Error(
+          `ticket asset ${kind}/${name} revision ${meta.revision} vanished mid-download`,
+        )
+      }
+      entries.push({ type: 'file', path: entry.path, content: decodeBase64(file.contentBase64) })
+    }
+    return { meta, entries }
+  }
+
+  async listTicketAssets(
+    repo: string,
+    ticketId: string,
+    opts?: { revisions?: boolean },
+  ): Promise<TicketAssetSummary[]> {
+    const query = opts?.revisions ? '?revisions=1' : ''
+    return this.requestJson(
+      'GET',
+      `${this.assetPath(repo, ticketId)}/list${query}`,
+      ticketAssetSummaryListSchema,
+    )
+  }
+
+  async removeTicketAsset(
+    repo: string,
+    ticketId: string,
+    kind: string,
+    name: string,
+  ): Promise<TicketAssetMeta | null> {
+    return this.requestJson(
+      'POST',
+      `${this.assetPath(repo, ticketId)}/remove`,
+      removeTicketAssetResponseSchema,
+      { kind, name },
+    )
+  }
+
   async claimRepoLease(repo: string, holder: string, ttlMs: number): Promise<boolean> {
     const result = await this.requestJson(
       'POST',
@@ -595,6 +886,23 @@ export class RemoteBuildStore implements BuildStore {
     return envelope as unknown as SessionEventEnvelope<T>
   }
 
+  async appendSessionEventIfCurrent<T extends SessionEventType>(
+    id: string,
+    expectedSeq: number,
+    event: SessionEventWrite<T>,
+  ): Promise<SessionEventEnvelope<T> | null> {
+    const envelope = await this.requestJson(
+      'POST',
+      `${this.sessionPath(id)}/events/conditional`,
+      conditionalSessionEventResponseSchema,
+      {
+        expectedSeq,
+        event: { actor: event.actor, type: event.type, payload: event.payload },
+      },
+    )
+    return envelope as SessionEventEnvelope<T> | null
+  }
+
   async getSessionEvents(
     id: string,
     sinceSeq = 0,

package/packages/core/src/store/remote/index.ts

@@ -1,7 +1,8 @@
+// Client half + shared wire vocabulary for the remote BuildStore (SPEC §7.2).
+// The HTTP server half ships in `@defrex/autobuild-hosted-store-service`;
+// this barrel is what a local CLI and the hosted package both build against.
 export { AuthError, RemoteBuildStore } from './client'
 export type { RemoteBuildStoreOptions, RemoteStoreIdentity } from './client'
-export { createStoreServer, startStoreServer } from './server'
-export type { StartStoreServerOptions, StoreServer, StoreServerOptions } from './server'
 export { mintToken, tokenResource, verifyToken } from './token'
 export type { OperatorTokenScope, TokenScope } from './token'
 export {
@@ -10,3 +11,14 @@ export {
   REMOTE_STORE_PROTOCOL_VERSION,
   REMOTE_STORE_PROTOCOL_VERSION_HEADER,
 } from './version'
+// The whole wire protocol: schemas, error vocabulary, and the placeholder-ref
+// deposit convention. The protocol servers (hosted package) compose these;
+// clients parse them for feedback.
+export * from './protocol'
+// Event vocabulary the wire envelopes and the server's D6 mapping rely on.
+export { EventValidationError } from '../../events/catalog'
+export type { Via } from '../../events/envelope'
+export type { SessionEvent, SessionEventWrite } from '../../events/sessions'
+export type { RepositoryEvent, RepositoryEventWrite } from '../../events/repository'
+export { SNAPSHOT_REDUCER_NAME } from '../snapshots'
+export type { ReducerSnapshot, SnapshotScope } from '../snapshots'

package/packages/core/src/store/remote/protocol.ts

@@ -24,6 +24,7 @@
  * Arbitrary computation over the assigned revisions inside `makeEvent`
  * (e.g. `rev + 1`, string interpolation) is unsupported by design.
  */
+import { reducerSnapshotWireSchema } from '../snapshots'
 import { z } from 'zod'
 import { actorSchema } from '../../events/envelope'
 import { ticketRefSchema } from '../../ontology'
@@ -40,6 +41,18 @@ export const errorBodySchema = z.object({
 })
 export type ErrorBody = z.infer<typeof errorBodySchema>
 
+/**
+ * Deliberately loose: the ontology is enforced by `validateEventWrite` in
+ * the *backing store* (§8), so its precise EventValidationError message —
+ * the agent feedback D6 exists for — survives the wire instead of being
+ * shadowed by a duplicate wire-schema error.
+ */
+export const eventWriteWireSchema = z.object({
+  actor: z.unknown(),
+  type: z.string().min(1),
+  payload: z.unknown(),
+})
+
 // ── Builds ───────────────────────────────────────────────────────────────────
 
 export const newBuildBodySchema = z.object({
@@ -51,6 +64,9 @@ export const newBuildBodySchema = z.object({
   repoOrigin: z.string().optional(),
   ticket: ticketRefSchema.optional(),
   branch: z.string().min(1).optional(),
+  // Additive optional initial `build.created` event, appended atomically with
+  // the record. Loose like every event wire schema: the backing store validates.
+  created: eventWriteWireSchema.optional(),
 })
 
 export const buildRecordWireSchema = z.object({
@@ -68,18 +84,6 @@ export const buildRecordListSchema = z.array(buildRecordWireSchema)
 
 // ── Events ───────────────────────────────────────────────────────────────────
 
-/**
- * Deliberately loose: the ontology is enforced by `validateEventWrite` in
- * the *backing store* (§8), so its precise EventValidationError message —
- * the agent feedback D6 exists for — survives the wire instead of being
- * shadowed by a duplicate wire-schema error.
- */
-export const eventWriteWireSchema = z.object({
-  actor: z.unknown(),
-  type: z.string().min(1),
-  payload: z.unknown(),
-})
-
 export const eventEnvelopeWireSchema = z.object({
   build: z.string(),
   seq: z.number().int().positive(),
@@ -117,6 +121,18 @@ export const repositoryEventEnvelopeWireSchema = z.object({
 })
 export const repositoryEventListSchema = z.array(repositoryEventEnvelopeWireSchema)
 
+/** `GET repos/:repo/high-water`: the journal's greatest assigned seq. */
+export const repoHighWaterSchema = z.object({ seq: z.number().int().nonnegative() })
+
+/** `GET builds|repos/:id/snapshots/:reducer?version=N`: the snapshot or `null`. */
+/** `PUT …/snapshots/:reducer` request body. */
+export const reducerSnapshotPutBodySchema = reducerSnapshotWireSchema
+
+export const reducerSnapshotResponseSchema = reducerSnapshotWireSchema.nullable()
+
+/** `PUT builds|repos/:id/snapshots/:reducer`: whether the row was written. */
+export const reducerSnapshotPutResponseSchema = z.object({ written: z.boolean() })
+
 export const repositoryArtifactMetaWireSchema = z.object({
   repo: z.string(),
   kind: z.string(),
@@ -138,6 +154,68 @@ export const repoDepositsResponseSchema = z.object({
   artifacts: repositoryArtifactMetaListSchema,
 })
 
+// ── Ticket assets (SPEC §7.1) ────────────────────────────────────────────────
+
+export const ticketAssetLayoutSchema = z.enum(['file', 'tree'])
+/** An entry on the put request: `{type:'file',path,contentBase64}` or `{type:'dir',path}`. */
+export const ticketAssetEntryWireInputSchema = z.discriminatedUnion('type', [
+  z.object({ type: z.literal('file'), path: z.string(), contentBase64: z.string() }),
+  z.object({ type: z.literal('dir'), path: z.string() }),
+])
+export const putTicketAssetBodySchema = z.object({
+  kind: z.string(),
+  name: z.string(),
+  layout: ticketAssetLayoutSchema,
+  entries: z.array(ticketAssetEntryWireInputSchema),
+})
+/** A manifest entry: `dir` entries carry no size or blobRef. */
+export const ticketAssetEntryWireSchema = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal('file'),
+    path: z.string(),
+    size: z.number().int().nonnegative(),
+    blobRef: z.string(),
+  }),
+  z.object({ type: z.literal('dir'), path: z.string() }),
+])
+export const ticketAssetMetaWireSchema = z.object({
+  repo: z.string(),
+  ticketId: z.string(),
+  kind: z.string(),
+  name: z.string(),
+  revision: z.number().int().nonnegative(),
+  layout: ticketAssetLayoutSchema,
+  size: z.number().int().nonnegative(),
+  entries: z.array(ticketAssetEntryWireSchema),
+  createdAt: z.string(),
+})
+export const ticketAssetSummaryWireSchema = z.object({
+  repo: z.string(),
+  ticketId: z.string(),
+  kind: z.string(),
+  name: z.string(),
+  revision: z.number().int().nonnegative(),
+  layout: ticketAssetLayoutSchema,
+  size: z.number().int().nonnegative(),
+  fileCount: z.number().int().nonnegative(),
+  dirCount: z.number().int().nonnegative(),
+  createdAt: z.string(),
+})
+export const ticketAssetSummaryListSchema = z.array(ticketAssetSummaryWireSchema)
+/** `GET …/assets` answers the manifest only (no bytes); null when absent or removed. */
+export const ticketAssetManifestResponseSchema = ticketAssetMetaWireSchema.nullable()
+/** `GET …/assets/file` answers one file's bytes; null when absent. */
+export const ticketAssetFileResponseSchema = z.object({ contentBase64: z.string() }).nullable()
+export const removeTicketAssetBodySchema = z.object({ kind: z.string(), name: z.string() })
+export const removeTicketAssetResponseSchema = ticketAssetMetaWireSchema.nullable()
+export const ticketAssetLimitsWireSchema = z.object({
+  maxBytes: z.number().int().nonnegative(),
+  maxEntries: z.number().int().positive(),
+  /** Largest request or response body the deployment can carry. Absent: no ceiling. */
+  maxRequestBytes: z.number().int().positive().optional(),
+})
+export type TicketAssetLimitsWire = z.infer<typeof ticketAssetLimitsWireSchema>
+
 // ── Operator sessions (SPEC §7.1.1) ─────────────────────────────────────────
 
 export const newSessionBodySchema = z.object({
@@ -166,6 +244,12 @@ export const sessionEventEnvelopeWireSchema = z.object({
 })
 export const sessionEventListSchema = z.array(sessionEventEnvelopeWireSchema)
 
+export const conditionalSessionEventBodySchema = z.object({
+  expectedSeq: z.number().int().nonnegative(),
+  event: eventWriteWireSchema,
+})
+export const conditionalSessionEventResponseSchema = sessionEventEnvelopeWireSchema.nullable()
+
 export const sessionArtifactMetaWireSchema = z.object({
   session: z.string(),
   kind: z.string(),
@@ -187,6 +271,25 @@ export const sessionDepositsResponseSchema = z.object({
   artifacts: sessionArtifactMetaListSchema,
 })
 
+// ── Build digests (repo-scoped batch read, AUT-487) ────────────────────────
+// The wire form of `BuildDigest` (store/types.ts). `terminal` is omitted when
+// the build's log carries no terminal fact, per the protocol's omission
+// convention for optional members.
+export const buildDigestWireSchema = z.object({
+  slug: z.string().min(1),
+  terminal: z.enum(['done', 'aborted']).optional(),
+  observations: z.array(
+    z.object({
+      seq: z.number().int().positive(),
+      ts: z.string().min(1),
+    }),
+  ),
+  merged: z.string().min(1).optional(),
+  reclaimPending: z.literal(true).optional(),
+  executionOpen: z.literal(true).optional(),
+})
+export const buildDigestListSchema = z.array(buildDigestWireSchema)
+
 // ── Artifacts ────────────────────────────────────────────────────────────────
 
 export const artifactMetaWireSchema = z.object({

package/packages/core/src/store/remote/version.ts

@@ -3,8 +3,12 @@ import manifest from '../../../../../package.json'
 /** Release-synchronized identity sent by every remote-store client. */
 export const AUTOBUILD_VERSION = manifest.version
 
-/** Wire compatibility version for the remote BuildStore protocol. */
-export const REMOTE_STORE_PROTOCOL_VERSION = '2'
+/** Wire compatibility version for the remote BuildStore protocol.
+ * Version 3 (AUT-521): the build-digest wire shape gains per-occurrence
+ * observation timestamps and the `merged` fact — a breaking shape change,
+ * so stale peers are rejected at handshake instead of failing mid-request
+ * at schema parse. */
+export const REMOTE_STORE_PROTOCOL_VERSION = '3'
 
 export const AUTOBUILD_VERSION_HEADER = 'x-autobuild-version'
 export const REMOTE_STORE_PROTOCOL_VERSION_HEADER = 'x-autobuild-protocol-version'