Skip to content
Browse lexicons
matching 41 lexicons
page.cavu
24
Narrow ›
-
page.cavu.authReader
permission-set
-
page.cavu.blocks.pageBreak
object
not from the namespace authority
An explicit page break: the content after it begins on a new page. A layout mark rather than content — it carries no text, so a document's textContent is unaffected by it. Paginated renderers (print, PDF, EPUB, paginated screen reading) should start a fresh page; continuous renderers may leave a little extra air or ignore it. Designed to sit inside pub.leaflet.pages.* open block unions; renderers that don't recognize it skip it, which degrades to no break at all.
-
page.cavu.blocks.screenplay
object
not from the namespace authority
One element of a screenplay: a scene heading, a paragraph of action, a character cue, a parenthetical, a run of dialogue or lyric, a transition, or centered text. A script is a flat sequence of these blocks, the paragraph-type model of Fountain and Final Draft; a speech is a character block followed by the parenthetical, dialogue and lyric blocks that belong to it. Renderers set each element by screenplay convention (a monospaced face, dialogue and cues indented, transitions flush right, heading
-
page.cavu.blocks.toc
object
not from the namespace authority
A table-of-contents block, modeled on the EPUB 3 navigation document: simultaneously machine-parseable navigation and rendered content. Designed to sit inside a pub.leaflet.pages.linearDocument (or canvas) open block union in the book's frontmatter document; renderers that don't recognize it skip it — the document's textContent should carry a plaintext TOC for previews and search. Book readers parse it for navigation UI and render it as a page in the reading flow.
-
page.cavu.blocks.verse
object
not from the namespace authority
A verse (poetry, song, inscription) block. Unlike prose blocks, whitespace is meaningful: a single newline is a hard line break, a blank line separates stanzas. Renderers should preserve line breaks, keep stanzas together, and style distinctly from prose (traditionally inset, often italic). Mirrors the shape of pub.leaflet.blocks.text so the same rich-text tooling applies. Designed to sit inside pub.leaflet.pages.* open block unions; renderers that don't recognize it skip it, so the document's t
-
page.cavu.book
object
Book extension object, embedded in a site.standard.publication record as a pass-through `book` property (the Leaflet `theme` pattern). Its presence marks the publication as a book; series publications omit it. The publication's standard fields remain the fallback identity (name = title, description = blurb, icon = square mark).
-
page.cavu.defs
defs
Appview projection of one book on the shelf: the join of a site.standard.publication record, its page.cavu.book extension, and index-time enrichment (chapter count read from the TOC document, aggregate rating from BookHive). Only renderable books are indexed — a publication with no book object, an empty spine, or content in an unrecognized format never appears as a view.
-
page.cavu.forge.attribute
record
not from the namespace authority
One word in a project's own vocabulary for facts. Nothing about what can be said of an entity is predefined — a genderless species has no gender, a starship has a registry, a magic system has its own terms — so each project defines the attributes its facts use. Defining one says how its facts combine (one value at a time, or several) and whether its values point at other entities — an attribute that does is a relation (allegiance, sails under, married to), named from both sides. A fact whose att
-
page.cavu.forge.defs
defs
not from the namespace authority
A link to another record in the same project space. Names the repo as well as the record because a shared project holds one repo per member, and a member's character is as linkable as the owner's.
-
page.cavu.forge.entity
record
not from the namespace authority
A thing in the story's world — a character, a place, an object, a group — reduced to an identity. Everything said about it, its name included, is a page.cavu.forge.fact anchored to the timeline, because nothing in a story is assumed static: people are renamed, age, move and die; places change hands and fall down. The record's key is the entity's id; its kind is the one thing that doesn't change.
-
page.cavu.forge.event
record
not from the namespace authority
Something that happens in the story's world, placed in story order on the project's timeline — or an epoch grouping such events. Events are the timeline facts are anchored to; epochs are sets of events (books, years, eras) that facts can be anchored to as a whole. Timeline order is story order (when it happens), not telling order (when the reader learns of it).
-
page.cavu.forge.fact
record
not from the namespace authority
Something true about an entity for a stretch of the story's timeline: its name, an age, where someone lives, who they're married to — in whatever terms the project defines (page.cavu.forge.attribute). Entities are bare identities; every attribute, the name included, is a fact. Nothing is assumed static. Time is the timeline's order, not dates: a fact holds from its `from` event (inclusive; absent = from the start) until its `until` event (exclusive; absent = onward). Unless the attribute is defi
-
page.cavu.forge.note
record
not from the namespace authority
A loose note in a StoryForge project: research, a scrap of dialogue, a plot problem to solve. Can be pinned to the entities and events it concerns. Notes are the writer's, about the book; facts are the story world's.
-
page.cavu.forge.project
space
not from the namespace authority
A StoryForge project: the working notes behind one book or series — its characters, places and things (entities whose every attribute is a fact on the timeline), the timeline of events, and loose notes (atproto permissioned data, proposal 0016). Anchored on the writer's own DID, so their PDS is both repo host and space host and nothing leaves it. Private by default (member-list policy, no members). Collaborators — a co-writer, an editor — join as members and write into their own repo inside the
-
page.cavu.forge.story
record
not from the namespace authority
What a StoryForge project is: one per project space, written by its owner.
-
page.cavu.getBook
query
One book's shelf view, hydrated with community counts the shelf list doesn't carry. The readerCount comes from a backlink index over page.cavu.progress records and is garnish, never load-bearing — it is omitted rather than guessed when the index is unreachable.
-
page.cavu.getFollowers
query
How many distinct readers follow a book: a count of site.standard.graph.subscription records pointing at the publication, via a network-wide backlink index. Garnish, never load-bearing — reports 0 when the upstream index is unreachable.
-
page.cavu.getShelf
query
The open shelf: every renderable book the appview has indexed, newest first (record keys are TIDs, so newest means most recently created). The index is fed network-wide from the firehose; any repo's book appears once its spine resolves to content the reader can render.
-
page.cavu.graph.authorSubscription
record
not from the namespace authority
Record declaring a subscription to an author — the sibling of site.standard.graph.subscription, which targets publications only. Following an author means wanting the books they have not written yet, so the subject is the author's DID rather than any record: a publication that does not exist yet cannot be referenced. One record per (reader, author) by convention: clients list their own repo and reuse the existing record rather than create a second (the same convention page.cavu.progress uses). T
-
page.cavu.group
record
What a group read is reading. Written by the host into their own repo inside a page.cavu.groupread space, under the fixed skey 'self' — one per space, so the space ref alone identifies the group and there is no second record to keep in sync. Deliberately thin: the roster lives with whoever administers membership (the PDS's member list, or the managing app), and every member's own activity lives in that member's repo in the same space. This record carries only what the whole group shares — which
-
page.cavu.groupread
space
A group read: one book, one host, and the people reading it together (atproto permissioned data, proposal 0016). Anchored on the host's DID, so the host's PDS is the space host and holds one repo per participant. Each member writes their own activity into their own repo inside the space — where they are in the book (page.cavu.progress, a mirror of the record in their personal space) and the passages they've marked and written about (at.margin.note, moved here from their personal space by an expl
-
page.cavu.pages
object
not from the namespace authority
Pre-paginated image content (comics, graphic novels, picture books, scanned pages) for a book chunk, carried in a site.standard.document record's `content` open union — the fixed-layout counterpart to a pub.leaflet.content text chunk. Each page is one image; readers lay pages into single-page or two-page-spread views using the book's pageProgression direction and each page's spread hint. The document's `textContent` field may carry a transcript or page descriptions for search and accessibility.
-
page.cavu.personal
space
A reader's private personal space (atproto permissioned data, proposal 0016): owner-only (member-list policy with no members), anchored on the reader's own DID so their PDS is also the space host, one per account under the fixed skey 'self'. Holds the reader's own activity that should not be public — where they are in a book, and the passages they've marked and written about. Annotations are at.margin.note, margin.at's W3C Web Annotation record: a foreign authority's lexicon deliberately, becaus
-
page.cavu.progress
record
Reading progress for one book, written to the reader's own repo. One record per (reader, publication) by convention: clients list their own repo and update the existing record for a publication rather than create a second (the BookHive shelf pattern). The publication AT-URI makes records discoverable by backlink index (Microcosm/Constellation), so 'who is reading this book' needs no app-side database. Positions anchor documents by strongRef: the cid pins the chunk *as read*, so a later edit to a
page.corvus
14
Narrow ›
-
page.corvus.backchannelFrame
defs
Wire format for messages a client sends server-bound over the same WebSocket opened by `page.corvus.subscribeOps`. Atproto's `subscription` lexicon type is server-push only — every server→client frame is defined under `page.corvus.subscribeOps`. The client→server side of the duplex socket is described here as a separate frame union. Clients dispatch on each message's `$type` discriminator (e.g. `page.corvus.backchannelFrame#op`).
**Multi-block.** A single WebSocket connection authenticates one
-
page.corvus.block
record
A block
-
page.corvus.contentBlocks
defs
Content block variants — atomic content types that compose into documents and database cells. Each sub-def is a block content shape selected by `page.corvus.block.blockType`.
-
page.corvus.core
defs
Shared primitives used across the corvus lexicons: id types (`#opId`, `#atomId`), the generic value primitives the applier materializes scalar / counter / set / sequence fields into (`#register`, `#counter`, `#orSet`, `#seq`), and the supporting types for `#seq` (`#run`, `#tombstone`). The `#block` def captures the envelope shape every variant in `page.corvus.block` inlines (`id`, `parent`, `afterSibling`); `#children` is a sentinel referenced by `editableAs` on ordered-children fields. Variants
-
page.corvus.database
object
A database block
-
page.corvus.document
object
A collection of text formatting document blocks
-
page.corvus.drawing
object
A drawing block — a vector image composed of shapes that render onto an HTML canvas 2D context. The drawing's `shapes` sequence holds shape block ids in z-order (later = on top). Each shape variant below is its own block. Coordinates are integer pixels; an editor that needs sub-pixel precision can scale its working coord space.
-
page.corvus.facets
object
A facet, facets are features that apply to a range of text, they're immutable. So changing a facet requires dropping the old facet and inserting a new one.
-
page.corvus.getBlock
query
Fetch materialized snapshots of an explicit set of blocks plus the `cursor` at the time of the snapshot. Bootstrap path for clients that don't want to replay history from scratch.
**Explicit set, no descent.** The server returns one snapshot per requested `blockId`. It does NOT walk children, references, or any other graph relation — the caller decides which blocks to materialize. To render a tree, the caller fetches a root, reads child block-ids out of its data, then issues a follow-up `getBlo
-
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
-
page.corvus.project
record
A project is a root document block with a list of collaborators
-
page.corvus.publishOps
procedure
HTTP alternative to streaming `page.corvus.backchannelFrame#op` frames over a `page.corvus.subscribeOps` WebSocket. Each entry is a `page.corvus.backchannelFrame#op` and is validated, ingested, and broadcast by the same code the backchannel uses, so the wire shape and semantics are identical. No response body — the server-assigned cursor is observed via `page.corvus.subscribeOps#op` echo, same as the backchannel. Ops are processed in order; the procedure stops at the first validation failure (op
-
page.corvus.subscribeOps
subscription
Subscribe to CRDT op streams from a corvus server over a single WebSocket connection. **Connection-scoped, multi-block**: one connection authenticates one DID and may carry subscriptions to many block sets. Subscribes and unsubscribes happen mid-connection via `page.corvus.backchannelFrame#subscribe` / `#unsubscribe` — the upgrade itself takes no parameters and starts with no active subscriptions.
**Subscriptions name an explicit block set.** A subscribe frame carries the `blockIds` the client
-
page.corvus.view
defs
View block variants — visualizations rendered over a database or SQL query (`page.corvus.database`). Each sub-def is a view shape selected by `page.corvus.block.blockType`.