The namespace a KV call without an explicit one binds to. A namespace is a
logical bucket: keys are unique within it, scans are scoped to it, and one
user’s namespaces stay isolated from another’s.
Page size a streaming reader pulls when the caller has not set an explicit
limit. Large enough to amortize round-trips, small enough that an
unbounded scan does not spike memory.
The most managed requests one mixed-operation batch
(AGDX_BATCH_CODE) may carry. Bounds the
server work one frame can demand. The assembled reply is additionally
bounded by MAX_FRAME_BYTES like any other.
Ceiling on a connection’s advertised metadata (AGDX_SET_CLIENT_METADATA).
The metadata is an opaque byte payload any client may set, not agent-only: an
agent advertises its card under the AGDX schema, a regular app sets whatever
blob its own tooling and the console interpret. The ceiling bounds the
per-connection state the streaming server holds and, because the discovery
read (AGDX_GET_CLIENTS_METADATA) returns a page of N connections at once, it
also bounds a page at N * this. 64 KiB is generous for any card or app blob
while keeping a page well under the frame cap even at the max page size.
Ceiling on one [len: u32 LE][bytes] frame on the managed-command sockets,
enforced by both the server and LaserData Cloud. A reply above it is replaced by
a structured too-large error rather than truncated. The u32 length prefix
addresses far more (4 GiB), so this is a deliberate per-frame memory bound on
the whole-frame buffer, not a transport limit. Every consumer of the managed
sockets (the server-side dispatch, the streaming server sidecar, the reply-byte budget)
MUST source this one constant rather than redefining its own frame cap, so
the layers cannot disagree and a reply admitted by one is not rejected by the
next. Changing it moves all of them in lockstep.
Maximum graph name length, in bytes. Bounded and control-character-free
like a namespace: the name keys the projection registry and every
traversal request.
Hard cap on the number of agdx.idx.* headers a single record may carry.
Total header byte size is already capped, but a buggy producer could stamp
dozens of tiny indexed scalars under the byte budget and slow the
projector. 32 covers every legitimate analytics row with head-room.
Maximum KV (and memory) namespace length, in bytes. A namespace is a
caller-chosen bucket name that flows into grant matching and scan scoping,
so it is bounded and control-character-free, while its charset stays open
(namespaces legitimately carry /-style hierarchy).
Hard ceiling on rows in a single query reply. A limit above it is
rejected with QueryError::TooLarge, and a 0 limit defaults to a full
page. Callers page through larger result sets with offset.
Cap on the payload bytes the projector inlines into a materialized row
(when inline_payload is set). This bounds only the copy kept alongside the
indexed row in the read-model backend, never the original message: the Iggy
log always retains the full bytes and a fetch can replay them. Held at
MAX_VALUE_BYTES (8 MiB) so a single inlined body and a single KV value
share one “max opaque value” ceiling. A body above it still indexes and
still lives in the log. It is just not duplicated into the row, so a typed
fetch decodes from the log (or a claim-check ContentType::Ref body). The
cap exists because multi-MB BLOBs per row bloat the embedded query DB and
slow scans.
Hard ceiling on a single query reply’s serialized bytes. A reply rides the
managed-command socket as one [len: u32 LE][bytes] frame, buffered whole,
so it is bounded by MAX_FRAME_BYTES by construction (the two are held
equal on purpose so anything a backend admits to a reply, the socket can
frame). Larger result sets are not returned as one oversized reply: they
page via MAX_PAGE_SIZE rows plus offset. Raising this means raising
MAX_FRAME_BYTES in lockstep across the server, LaserData Cloud, and the
socket buffer, since it is the same frame.
Max encoded bytes of a node or edge source provenance reference. A source
names a stream, topic, key, or id, all of which are bounded inputs already,
so this is a defensive ceiling against a hostile or buggy upsert inflating
per-element state. Sized at two key-lengths, since the largest variant (a
key-value source) names both a namespace and a key, far under the opaque
value ceiling, as a source ref is a short pointer, not a payload.