Lexicon Garden

zone.stratos.sync.listRepoOps

Incremental pull sync of a repo's operation log (oplog), mirroring com.atproto.space.listRepoOps semantics. Returns record operations after the `since` revision, with current record values inlined by default. Boundary-gated: the caller only observes operations for records within its enrolled boundaries. The response reaches the head of the oplog when `cursor` is absent; the repo's current signed commit is then included (unless the repo has no commits yet), consistent with the operations returned. When a concurrent write is detected, a cursor is returned instead of the commit; that response can carry no operations and repeat the cursor you sent, so poll again while a cursor is present and do not read an unchanged cursor as a stall. A write that commits after the head probe is not detected; it falls outside this snapshot and arrives on a later poll. Callers must authenticate with a signed service JWT via the Authorization: Bearer header. The oplog is a droppable transport optimization; if `since` predates retained history the OplogTruncated error is returned (stricter than upstream, which silently restarts) so the caller falls back to full-state recovery (listRecordPaths).

Repository @lexicon.northsky.app did:plc:6uxgo3ypovauub7nblwylqyv namespace authority
Details · query
Kindquery
Authoritysync.stratos.zone
Indexed
Compare Edit in builder → Fork →

Query

query · GET

Parameters

query string

cursor

string

Opaque pagination cursor from a previous response. Takes precedence over `since` when both are supplied.

did

requiredstring · did

The DID of the repo to sync.

excludeValues

boolean

When true, record values are omitted and only operation metadata is returned.

  • default: false

limit

integer

Maximum number of operations to return in this page.

  • minimum: 1
  • maximum: 1000
  • default: 100

since

string · tid

A revision (TID): the caller's own sync position. Only operations after this revision are returned. Omit to start from the beginning of retained history. Use `cursor` to continue a paginated response.

Output

application/json

commit

ref

The repo's current signed MST commit. Included when the response reaches the head of the oplog; omitted on backfill responses and when the repo has no commits yet (no writes) - in that case there is nothing to sign and also no ops to sync.

Reference

cursor

string

Opaque pagination cursor to fetch the next page. Absent once the response reaches the head of the oplog. Can repeat the cursor you sent when a concurrent write was detected.

ops

requiredarray

The operations in this page, in ascending revision order.

itemsref
Reference

Errors

OplogTruncated

The requested `since` revision falls outside retained history: it predates the oldest retained event (compacted), postdates the newest (not a rev this repo issued), or there is no retained log to check it against. Also returned for an unusable `cursor`: malformed, predating retained history (compacted between pages), or beyond the newest retained event. The caller must fall back to full-state recovery. Stricter than upstream, which restarts from the beginning of retained history instead of erroring.

RepoNotFound

The requested repo does not exist.

AuthRequired

Service authentication is required.

#repoOp

object

A single record operation in the oplog. `cid` null means delete; `prev` null means create.

Properties

cid

requiredstring · cid

The CID (string form) of the current record value. Null for a delete.

  • nullable

collection

requiredstring · nsid

The record collection.

prev

requiredstring · cid

The CID (string form) of the record value this operation superseded. Null for a create, or when the superseded value predates the returned window.

  • nullable

rev

requiredstring · tid

The revision of the commit that produced this operation. Atomic multi-writes share one rev.

rkey

requiredstring · record-key

The record key.

value

unknown

The current record value, inlined by default for create/update ops. Omitted when excludeValues is true, for a delete, or when the value has been superseded by a later operation.

#signedCommit

object

A signed MST v3 commit, as persisted (read verbatim, not re-signed).

Properties

data

requiredstring · cid

The CID (string form) of the MST root node.

did

requiredstring · did

The DID of the repo.

prev

string · cid

The CID (string form) of the previous commit. Absent for the first commit.

rev

requiredstring · tid

The commit revision.

sig

requiredstring

The commit signature, base64-encoded (the exact persisted bytes).

version

requiredinteger

The commit version (3).

Similar lexicons

semantic match

Lexicons whose schemas describe something close to this one. Check them before publishing a new one that overlaps.

  • zone.stratos.sync.listRecordPaths

    query

    Full-state recovery: enumerate a repo's record paths and their current CIDs, mirroring listRecords semantics. Record values are inlined by default; excludeValues returns metadata only. Boundary-gated: the caller only observes records within its enrolled boundaries. Intended as the fallback when the oplog (listRepoOps) returns OplogTruncated: the caller enumerates paths, diffs locally, and fetches misses. Callers must authenticate with a signed service JWT via the Authorization: Bearer header.

  • zone.stratos.sync.getRepo

    query

    Export the full repository as a CAR file. Returns all record blocks, MST nodes, and the signed commit.

  • com.atproto.sync.listBlobs

    query

    List blob CIDs for an account, since some repo revision. Does not require auth; implemented by PDS.

  • page.corvus.getOps

    query

    Paginated forward read of an op log scoped to an explicit block set. Pull-based alternative to opening a `page.corvus.subscribeOps` WebSocket at `cursor: 0` — same op shape, same cursor semantics, just delivered as a query page instead of a live tail. Each entry is a `page.corvus.subscribeOps#op` so live and historical paths feed the same applier. Like `subscribeOps`, this query does NOT walk graph relations. Callers fetch ops for the blocks they care about and follow refs explicitly with subse