@defrex/autobuild 0.8.0 → 0.9.0

package/packages/core/src/store/memory.ts

@@ -26,12 +26,28 @@ import {
 } from '../events/sessions'
 import { humanActor } from '../events/envelope'
 import { createBuildScopedStore } from './build-scope'
+import { validateCreatedEvent } from './new-build'
 import { createSessionScopedStore } from './session-handle'
+import { reduceBuildDigest } from './digest'
+import { projectRepositoryStateEvents } from './repo-state-events'
 import {
   DEFAULT_ARTIFACT_RETENTION_MAX_REVISIONS,
   isRetentionManagedKind,
   revisionsToPrune,
 } from './retention'
+import {
+  DEFAULT_TICKET_ASSET_LIMITS,
+  loadTicketAsset,
+  resolvePinnedAsset,
+  storeTicketAssetBlobs,
+  summarizeTicketAsset,
+  validateTicketAssetInput,
+  type TicketAsset,
+  type TicketAssetInput,
+  type TicketAssetLimits,
+  type TicketAssetMeta,
+  type TicketAssetSummary,
+} from './ticket-assets'
 import { pollingSubscribe } from './subscribe'
 import { StreamLocks } from './streams/lock'
 import { assembleUIMessageDocument } from './streams/assemble'
@@ -62,6 +78,7 @@ import {
   type ArtifactMeta,
   type BlobStore,
   type BuildRecord,
+  type BuildDigest,
   type BuildScopedStore,
   type BuildStore,
   type Clock,
@@ -146,6 +163,9 @@ export class MemoryBuildStore implements BuildStore {
    * stream's close against its appends inside this process (AUT-348). */
   private readonly streamLocks = new StreamLocks()
   private readonly sessions = new Map<string, SessionState>()
+  /** `[repo, ticketId, kind, name]` → rows in revision order. A removal is a
+   * tombstone row (`removed`, empty manifest) taking the next revision. */
+  private readonly ticketAssets = new Map<string, { meta: TicketAssetMeta; removed: boolean }[]>()
   private readonly clock: Clock
   private readonly maxRevisions: number
   readonly blobs: BlobStore
@@ -244,6 +264,7 @@ export class MemoryBuildStore implements BuildStore {
   }
 
   async createBuild(input: NewBuildInput): Promise<BuildRecord> {
+    const created = validateCreatedEvent(input)
     if (this.builds.has(input.slug)) {
       throw new Error(`build "${input.slug}" already exists`)
     }
@@ -261,6 +282,18 @@ export class MemoryBuildStore implements BuildStore {
       events: [],
       artifacts: new Map(),
     }
+    if (created !== undefined) {
+      state.events.push(
+        structuredClone({
+          build: input.slug,
+          seq: 1,
+          ts,
+          actor: created.actor,
+          type: created.type,
+          payload: created.payload,
+        }) as AbEvent,
+      )
+    }
     this.builds.set(input.slug, state)
     return this.snapshot(state)
   }
@@ -274,6 +307,22 @@ export class MemoryBuildStore implements BuildStore {
     return [...this.builds.values()].map((state) => this.snapshot(state))
   }
 
+  async getRepoBuildDigests(repo: string): Promise<Map<string, BuildDigest>> {
+    // Insertion order is creation order (the listSessions tiebreak note); the
+    // digest map is returned in slug order so every adapter answers the same
+    // shape for the same store contents.
+    const slugs = [...this.builds.entries()]
+      .filter(([, state]) => state.record.repo === repo)
+      .map(([slug]) => slug)
+      .sort()
+    const digests = new Map<string, BuildDigest>()
+    for (const slug of slugs) {
+      const state = this.builds.get(slug)!
+      digests.set(slug, { slug, ...reduceBuildDigest(state.events) })
+    }
+    return digests
+  }
+
   async append<T extends EventType>(slug: string, event: EventWrite<T>): Promise<EventEnvelope<T>> {
     const state = this.state(slug)
     const validated = validateEventWrite(event)
@@ -629,6 +678,14 @@ export class MemoryBuildStore implements BuildStore {
     })
   }
 
+  async getRepoStateEvents(repo: string): Promise<RepositoryEvent[]> {
+    // The oracle runs on the in-memory journal itself, which keeps the pure
+    // derivation honest against real adapter data.
+    return structuredClone(
+      projectRepositoryStateEvents(this.repoState(repo).events as RepositoryEvent[]),
+    )
+  }
+
   async putRepoArtifact(repo: string, artifact: ArtifactInput): Promise<RepositoryArtifactMeta> {
     const state = this.repoState(repo)
     if (!artifact.kind) throw new Error('artifact kind is required')
@@ -676,6 +733,102 @@ export class MemoryBuildStore implements BuildStore {
     )
   }
 
+  async ticketAssetLimits(_repo: string): Promise<TicketAssetLimits> {
+    return { ...DEFAULT_TICKET_ASSET_LIMITS }
+  }
+
+  async putTicketAsset(
+    repo: string,
+    ticketId: string,
+    asset: TicketAssetInput,
+  ): Promise<TicketAssetMeta> {
+    const size = validateTicketAssetInput(asset)
+    const entries = await storeTicketAssetBlobs(this.blobs, asset.entries)
+    const key = JSON.stringify([repo, ticketId, asset.kind, asset.name])
+    const rows = this.ticketAssets.get(key) ?? []
+    const meta: TicketAssetMeta = {
+      repo,
+      ticketId,
+      kind: asset.kind,
+      name: asset.name,
+      revision: MemoryBuildStore.nextRevision(rows.map((row) => row.meta)),
+      layout: asset.layout,
+      size,
+      entries,
+      createdAt: this.now(),
+    }
+    rows.push({ meta, removed: false })
+    this.ticketAssets.set(key, rows)
+    return structuredClone(meta)
+  }
+
+  async getTicketAsset(
+    repo: string,
+    ticketId: string,
+    kind: string,
+    name: string,
+    rev?: number,
+  ): Promise<TicketAsset | null> {
+    const rows = this.ticketAssets.get(JSON.stringify([repo, ticketId, kind, name]))
+    const row =
+      rev === undefined ? rows?.at(-1) : rows?.find((candidate) => candidate.meta.revision === rev)
+    if (!row || row.removed) return null
+    return loadTicketAsset(this.blobs, row.meta)
+  }
+
+  async getPinnedTicketAsset(
+    slug: string,
+    kind: string,
+    name: string,
+    rev?: number,
+  ): Promise<TicketAsset | null> {
+    return resolvePinnedAsset(this, slug, kind, name, rev)
+  }
+
+  async listTicketAssets(
+    repo: string,
+    ticketId: string,
+    opts?: { revisions?: boolean },
+  ): Promise<TicketAssetSummary[]> {
+    const out: TicketAssetSummary[] = []
+    for (const rows of this.ticketAssets.values()) {
+      const first = rows[0]
+      if (!first || first.meta.repo !== repo || first.meta.ticketId !== ticketId) continue
+      if (opts?.revisions) {
+        for (const row of rows) if (!row.removed) out.push(summarizeTicketAsset(row.meta))
+      } else {
+        const latest = rows.at(-1)
+        if (latest && !latest.removed) out.push(summarizeTicketAsset(latest.meta))
+      }
+    }
+    return out.sort(
+      (a, b) =>
+        a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name) || a.revision - b.revision,
+    )
+  }
+
+  async removeTicketAsset(
+    repo: string,
+    ticketId: string,
+    kind: string,
+    name: string,
+  ): Promise<TicketAssetMeta | null> {
+    const rows = this.ticketAssets.get(JSON.stringify([repo, ticketId, kind, name]))
+    const latest = rows?.at(-1)
+    if (!rows || !latest || latest.removed) return null
+    rows.push({
+      meta: {
+        ...latest.meta,
+        revision: latest.meta.revision + 1,
+        size: 0,
+        entries: [],
+        createdAt: this.now(),
+      },
+      removed: true,
+    })
+    return structuredClone(latest.meta)
+  }
+
   async claimRepoLease(repo: string, holder: string, ttlMs: number): Promise<boolean> {
     const state = this.repoState(repo)
     const now = this.clock().getTime()
@@ -791,6 +944,32 @@ export class MemoryBuildStore implements BuildStore {
     return envelope
   }
 
+  async appendSessionEventIfCurrent<T extends SessionEventType>(
+    id: string,
+    expectedSeq: number,
+    event: SessionEventWrite<T>,
+  ): Promise<SessionEventEnvelope<T> | null> {
+    const state = this.sessionState(id)
+    validateExpectedSeq(expectedSeq)
+    const validated = validateSessionEventWrite(event)
+
+    // No await occurs between comparison and mutation. JavaScript's run-to-
+    // completion semantics make this one atomic critical section even when
+    // concurrent remote requests interleave elsewhere in the adapter.
+    if (state.events.length !== expectedSeq) return null
+    const envelope = {
+      session: id,
+      seq: expectedSeq + 1,
+      ts: this.now(),
+      actor: validated.actor,
+      type: validated.type,
+      payload: validated.payload,
+    } as SessionEventEnvelope<T>
+    state.events.push(structuredClone(envelope) as SessionEvent)
+    state.record.updatedAt = envelope.ts
+    return envelope
+  }
+
   async getSessionEvents(
     id: string,
     sinceSeq = 0,

package/packages/core/src/store/new-build.ts

@@ -0,0 +1,17 @@
+import { EventValidationError, validateEventWrite, type EventWrite } from '../events/catalog'
+import type { NewBuildInput } from './types'
+
+/** Validate `input.created` before an adapter opens its create transaction, so
+ * an invalid initial event creates nothing. Returns the validated write. */
+export function validateCreatedEvent(
+  input: NewBuildInput,
+): EventWrite<'build.created'> | undefined {
+  if (input.created === undefined) return undefined
+  const validated = validateEventWrite(input.created)
+  if (validated.type !== 'build.created') {
+    throw new EventValidationError(
+      `createBuild's initial event must be "build.created", got "${validated.type}"`,
+    )
+  }
+  return validated as EventWrite<'build.created'>
+}

package/packages/core/src/store/phase-session.ts

@@ -23,6 +23,7 @@ import type {
   Artifact,
   ArtifactInput,
   ArtifactMeta,
+  BuildDigest,
   BuildRecord,
   BuildStore,
   NewBuildInput,
@@ -35,6 +36,13 @@ import type {
   SubscribeOptions,
   Unsubscribe,
 } from './types'
+import type {
+  TicketAsset,
+  TicketAssetInput,
+  TicketAssetLimits,
+  TicketAssetMeta,
+  TicketAssetSummary,
+} from './ticket-assets'
 import type {
   StreamChunk,
   StreamOutcome,
@@ -316,6 +324,14 @@ export function scopeLocalStoreToPhaseSession(
       own('getRepoEvents', 'repo', repo)
       return store.getRepoEvents(repo, sinceSeq, opts)
     },
+    async getRepoStateEvents(repo: string): Promise<RepositoryEvent[]> {
+      own('getRepoStateEvents', 'repo', repo)
+      return store.getRepoStateEvents(repo)
+    },
+    async getRepoBuildDigests(repo: string): Promise<Map<string, BuildDigest>> {
+      own('getRepoBuildDigests', 'repo', repo)
+      return store.getRepoBuildDigests(repo)
+    },
     async putRepoArtifact(repo: string, artifact: ArtifactInput): Promise<RepositoryArtifactMeta> {
       own('putRepoArtifact', 'repo', repo)
       return store.putRepoArtifact(repo, artifact)
@@ -332,6 +348,54 @@ export function scopeLocalStoreToPhaseSession(
       own('listRepoArtifacts', 'repo', repo)
       return store.listRepoArtifacts(repo, kind)
     },
+    async ticketAssetLimits(repo: string): Promise<TicketAssetLimits> {
+      own('ticketAssetLimits', 'repo', repo)
+      return store.ticketAssetLimits(repo)
+    },
+    async putTicketAsset(
+      repo: string,
+      ticketId: string,
+      asset: TicketAssetInput,
+    ): Promise<TicketAssetMeta> {
+      own('putTicketAsset', 'repo', repo)
+      return store.putTicketAsset(repo, ticketId, asset)
+    },
+    async getTicketAsset(
+      repo: string,
+      ticketId: string,
+      kind: string,
+      name: string,
+      rev?: number,
+    ): Promise<TicketAsset | null> {
+      own('getTicketAsset', 'repo', repo)
+      return store.getTicketAsset(repo, ticketId, kind, name, rev)
+    },
+    async getPinnedTicketAsset(
+      slug: string,
+      kind: string,
+      name: string,
+      rev?: number,
+    ): Promise<TicketAsset | null> {
+      own('getPinnedTicketAsset', 'build', slug)
+      return store.getPinnedTicketAsset(slug, kind, name, rev)
+    },
+    async listTicketAssets(
+      repo: string,
+      ticketId: string,
+      opts?: { revisions?: boolean },
+    ): Promise<TicketAssetSummary[]> {
+      own('listTicketAssets', 'repo', repo)
+      return store.listTicketAssets(repo, ticketId, opts)
+    },
+    async removeTicketAsset(
+      repo: string,
+      ticketId: string,
+      kind: string,
+      name: string,
+    ): Promise<TicketAssetMeta | null> {
+      own('removeTicketAsset', 'repo', repo)
+      return store.removeTicketAsset(repo, ticketId, kind, name)
+    },
     async claimRepoLease(repo: string, holder: string, ttlMs: number): Promise<boolean> {
       own('claimRepoLease', 'repo', repo)
       return store.claimRepoLease(repo, holder, ttlMs)
@@ -390,6 +454,13 @@ export function scopeLocalStoreToPhaseSession(
     ): Promise<SessionEventEnvelope<T>> {
       return admin('appendSessionEvent')
     },
+    appendSessionEventIfCurrent<T extends SessionEventType>(
+      _id: string,
+      _expectedSeq: number,
+      _event: SessionEventWrite<T>,
+    ): Promise<SessionEventEnvelope<T> | null> {
+      return admin('appendSessionEventIfCurrent')
+    },
     getSessionEvents(_id: string, _sinceSeq?: number): Promise<SessionEvent[]> {
       return admin('getSessionEvents')
     },

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

@@ -32,9 +32,21 @@ 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 { BuildDigest } from '../types'
 import type {
   StreamChunk,
   StreamOutcome,
@@ -68,9 +80,11 @@ import {
   artifactGetResponseSchema,
   artifactMetaListSchema,
   artifactMetaWireSchema,
+  buildDigestListSchema,
   buildRecordListSchema,
   buildRecordWireSchema,
   conditionalEventResponseSchema,
+  conditionalSessionEventResponseSchema,
   decodeBase64,
   depositsResponseSchema,
   encodeBase64,
@@ -96,6 +110,12 @@ import {
   sessionRecordWireSchema,
   streamChunkWireSchema,
   streamReadWireSchema,
+  ticketAssetFileResponseSchema,
+  ticketAssetLimitsWireSchema,
+  ticketAssetManifestResponseSchema,
+  ticketAssetMetaWireSchema,
+  ticketAssetSummaryListSchema,
+  removeTicketAssetResponseSchema,
   streamRecordListSchema,
   streamRecordWireSchema,
 } from './protocol'
@@ -187,7 +207,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 +229,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 +276,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 +535,19 @@ export class RemoteBuildStore implements BuildStore {
     )
   }
 
+  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 +587,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 +837,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,