dawn · operations surface

Instance dawn.core.bitnode.dev

Contract 2026-09-19 · build 51a1e42f29a627a498a6f664220c63b5309a94bd · go1.26.3 · generated 2026-09-17T22:31:36Z from https://dawn.core.bitnode.dev/api/operations/describe

Bindings

Primary	http
HTTP	prefix `/v1`
Socket	upgrade at `/v1/ws`, subprotocol `dawn`

Operations

Name	Kind	Grant	Binding	Request	Response	Parameters	Refusals
`livez`	operational		`GET /livez`		Health
`health`	operational		`GET /healthz`		Health
`describe`	operational		`GET /describe`		Describe
`describe_file`	operational		`GET /describe/{file...}`			file: string (required)	not_found
`resolve`	read	read	`GET /v1/resolve` socket		ResolveResult	path: strings (required)	not_found, unavailable
`children`	read	read	`GET /v1/children` socket		ChildrenPage	path: strings, through: int, cursor: string, limit: int	not_found, invalid_cursor, limit_exceeded, unavailable
`entries`	read	read	`GET /v1/entries` socket		EntriesPage	path: strings (required), after: int, through: int, limit: int	not_found, invalid_cursor, limit_exceeded, unavailable
`get`	read	read	`GET /v1/get` socket		RecordRead	root_id: string (required), space_id: string (required), position: int (required)	not_found, unavailable
`fetch`	stream	read	`GET /v1/fetch`		bytes	path: strings (required), bytes: string (required)	not_found, unresolved, unavailable
`snapshot`	read	read	`GET /v1/snapshot` socket		Snapshot	path: strings, depth: int	not_found, limit_exceeded, unavailable
`retain`	mutation	publish	`PUT /v1/retain`	bytes	RetainResult	path: strings (required), type: string (required)	invalid_record, unavailable
`publish`	mutation	publish	`POST /v1/publish` socket	PublishRequest	PublishResult		not_found, exists, conflict, idempotency_mismatch, invalid_record, unresolved, structural, limit_exceeded, unavailable
`create_artifact`	mutation	publish	`POST /v1/artifacts` socket	CreateArtifactRequest	ArtifactResult		not_found, exists, conflict, idempotency_mismatch, invalid_record, unresolved, structural, limit_exceeded, unavailable
`declare`	mutation	declare	`POST /v1/declarations` socket	DeclareRequest	DeclareResult		not_found, exists, conflict, idempotency_mismatch, invalid_record, unresolved, structural, limit_exceeded, unavailable
`compose`	mutation	publish	`POST /v1/compose` socket	ComposeRequest	PublishResult		not_found, exists, conflict, idempotency_mismatch, invalid_record, unresolved, structural, limit_exceeded, unavailable
`apply`	mutation	publish	`POST /v1/applications` socket	ApplyRequest	ApplyResult		not_found, exists, conflict, idempotency_mismatch, invalid_record, unresolved, structural, limit_exceeded, unavailable
`query`	read	read	`POST /v1/query` socket	QueryRequest	QueryResult		not_found, unresolved, invalid_cursor, unavailable
`explain`	read	read	`POST /v1/explain` socket	ExplainRequest	ExplainResult		not_found, unresolved, unavailable
`create_project`	mutation	provision	`POST /v1/projects` socket	CreateProjectRequest	SpaceResult		not_found, exists, conflict, idempotency_mismatch, structural, limit_exceeded, unavailable
`provision_worker`	mutation	provision	`POST /v1/workers` socket	ProvisionWorkerRequest	ProvisionWorkerResult		not_found, exists, conflict, idempotency_mismatch, structural, limit_exceeded, unavailable
`retire_worker`	mutation	provision	`POST /v1/workers/retire` socket	RetireWorkerRequest	PublishResult		not_found, exists, conflict, idempotency_mismatch, structural, limit_exceeded, unavailable
`create_campaign`	mutation	provision	`POST /v1/campaigns` socket	CreateCampaignRequest	PublishResult		not_found, exists, conflict, idempotency_mismatch, structural, limit_exceeded, unavailable
`assign`	mutation	provision	`POST /v1/assignments` socket	AssignRequest	PublishResult		unresolved, not_found, exists, conflict, idempotency_mismatch, structural, limit_exceeded, unavailable
`export`	read	provision	`GET /v1/export` socket		Export	path: strings, cursor: string	not_found, invalid_cursor, limit_exceeded, unavailable
`subscribe`	session	read	`socket message subscribe` socket	SubscribeRequest	SubscribeResult		not_found, invalid, limit_exceeded, unavailable
`unsubscribe`	session	read	`socket message unsubscribe` socket		UnsubscribeResult	subscription: string (required)	not_found

Refusals

Code	HTTP	Meaning
`not_found`	404	the path, space, occurrence, record or file is not here; shared with Journal
`exists`	409	a child of that key already exists under the parent, or the record identity is occupied; shared with Journal
`conflict`	409	an expected cutoff did not hold; carries the expected and actual cutoffs; shared with Journal
`idempotency_mismatch`	409	the operation ID was accepted before with a different semantic request; shared with Journal
`invalid`	400	a value is outside its grammar, limit or structural rule, or a cutoff is inside a batch or in the future
`invalid_cursor`	400	a malformed cursor, or one of another enumeration, traversal or query
`limit_exceeded`	413	a declared resource bound would be exceeded: a value, a batch, a page, a manifest or a continuation; shared with Journal
`unavailable`	503	a backend, a selected journal or a required observation cannot currently be served; recovery data that cannot be read is unavailable, never absent
`unverified`	401	the signature, freshness, audience or key admissibility failed; nothing was evaluated
`denied`	403	no grant chain reaches the principal for this kind on this path; whether the path exists is not revealed
`invalid_record`	400	the record does not validate against its interpretation profile, or an occurrence violates dawn-facts-v2; carries the field
`unresolved`	409	a record or request refers to content or an occurrence that does not resolve; carries the reference
`structural`	400	a user label collides with the layout's structural labels at that position, or a write targets a protected space

Files served

Each one verbatim, byte for byte what the listener served at /describe/{file}.

SURFACE.md

The Dawn semantic surface

Status: current development contract, 2026-09-19. This document owns Dawn's observable semantics. HTTP.md and WS.md bind the same operations. This revision replaces, in one landing, the 2026-09-17 production surface and the 2026-09-18 subscription frame, and is not additive against either. Against the 2026-09-17 surface it renames production to application and the verb produce to apply — the application surface of decision 0005 — the fact profile becomes dawn-facts-v2, and both worlds restart empty; nothing migrates. Against the 2026-09-18 frame it replaces the event shape with a journal's advance, one per journal, coalesced, with no cutoffs at open, no backfill and no kinds, per decision 0006. A server never answers 2026-09-18, a contract a client may already have been built against, because produce is gone. STATUS.md records implementation progress, including which operations of this contract the current source still leaves unimplemented, and ACCEPTANCE.md records evidence for specific builds; neither a contract change nor an older passing result establishes deployment of this revision. The 2026-09-11 contract was replaced in place: its storage was Registry, and its public vocabulary was Registry's model (order 0003, decision D-A). The Registry vocabulary is removed with no alias: forking has no successor (order 0002 D2); listing, history and views are children, entries and snapshot; coordinates with a global revision, publications, bindings and the contribution profile are gone. A request naming a removed verb is not_found.

Dawn gives workers a shared place to inspect artifacts and append attributed findings. Coordinators retain inputs, grant authority, select findings into views and run campaigns. Workers use Dawn; Dawn consumes the external Journal and Bytes services. Journal owns spaces, append-only journals of canonical facts, occurrence coordinates and retry receipts. Bytes owns retained content. Dawn owns authentication, authorization, semantic admission and the provenance Journal does not supply.

Values and identity

Term	Meaning
World	One Dawn deployment's subtree `/worlds/<world>` of one Journal root, with its configured name, root key and Bytes endpoint
Principal	An Archon Ed25519 public key authenticated for one request
Path	Labels below the world, one per entry; the world itself is the empty path
Space	A space's exact Journal identity `{root_id, space_id}` with its Dawn path
Occurrence	An `EntryRef` `{root_id, space_id, position}`: one entry of one journal; positions are per journal, never a global revision
Artifact	Exact retained content with a selected interpretation, `{bytes, type}`; the type selects a reading of the bytes, not an exclusive classification or a second identity
Content	The one `content` fact of an artifact space
Subject	A qualified `space#local` identity within an interpretation of an artifact; distinct from a path or a worker
Declaration	One immutable assertion occurrence about an artifact's exact content and optional subject, with its retained signed envelope and frame
Record	One admitted record occurrence with its profile, retained payload, metadata and Dawn's admission provenance
Grant	A Thesmos fact authorizing a principal's operation kind on a subtree until a time
Manifest	An explicit selection of journal prefixes with their cutoffs, retained in Bytes and cited by digest
Campaign / assignment	Coordination records binding a worker to pinned inputs, intended outputs and a brief
Tool	A configured provider Dawn runs; its logical name is an organizer under the world's `tools`, and each configured release is an artifact space under `tools/<name>/releases/<digest>`
Release	One configured executable of a tool; its `content` fact is the tool's description — name, version, class, input and output roles, effects, whether it is deterministic, its egress and its executable identity
Application	One run of a tool Dawn performed on a valuation, admitted as an attempt occurrence A, one `bound` fact per required input role, and completed as a sealed batch of produced outputs; attested by Dawn, never reported by a caller

Artifact content, subject identity, assertion identity, authenticated publisher and occurrence are separate. Two workers can assert different statements about the same artifact and subject. Both statements remain available; arrival order does not choose which one a consumer accepts. Publishing a statement does not establish its truth or adopt it for a view.

The world's spaces

Journal enforces unique child keys under a parent, one parent per space and no removal. Dawn assigns meaning to the layout:

/worlds/<world>
  /tools/<tool>                    organizer (the world's roots)
    /releases/<digest>             artifact space: content = the release's description; declarations child
      /declarations                one fact per declaration (leaf)
  /projects/<project>
    /artifacts/<artifact>          staged(A) first when an application created it; content; declarations child
      /declarations                one fact per declaration (leaf)
    /applications/<name>           leaf: attempt · refusal records · bound* · produced* + result (one batch) · reuse
    /snapshots/<name>              record journal (leaf)
    /inventories/<name>            record journal (leaf)
    /views/<name>                  record journal (leaf)
    /workers/<worker>
      /state                       record journal (leaf)
      /notes/<name>                record journal (leaf)
  /campaigns/<campaign>
    /state                         record journal (leaf)
    /assignments/<name>            record journal (leaf)
    /evidence/<name>               record journal (leaf)

A leaf is an individual record or declarations space under which Dawn never creates children, so its Dawn-created entries have origin append. The collection spaces tools, releases, applications, snapshots, inventories, views, notes, assignments and evidence are organizers, not leaves; two named views have independent histories and current records. Organizers have their own journals and are included in exports. Workers remain under their project: a worker's state or notes describes that worker, and declarations about an artifact remain in that artifact's declarations journal regardless of which worker submitted them. The publisher occurs in provenance, never in the placement rule.

Dawn ensures /worlds, the selected world and its organizing spaces with stable scoped operation IDs and resumes creation through Journal receipts after a partial setup or an uncertain response; it ensures one artifact space under tools per configured tool the same way. The labels tools, releases, artifacts, declarations, applications, snapshots, inventories, views, workers, notes, state, assignments and evidence are structural where the layout places them. A user label cannot shadow a structural label at its reserved position. The content of an artifact is a fact of its space, not a child.

The fact profile

Every fact Dawn writes is a canonical Ontos tuple headed by an atom under Journal's ulab-journal-facts-v1 profile. Dawn's profile is dawn-facts-v2, owned by the API's facts package; generated schemas describe it and do not define it.

Predicate	Arguments	Written in
`content`	`artifact`	an artifact space, exactly once
`record`	`profile`, `hash`, `metadata`, `publisher`, `request_id`, `request_digest`, `accepted_at`	an individual record's leaf space
`declaration`	`assertion_id`, `envelope`, `artifact`, `subject`, `publisher`, `application`	a `declarations` space
`attempt`	`release`, `request`, `publisher`, `request_id`, `request_digest`, `accepted_at`	an application leaf, once, heading its batch
`bound`	`application`, `role`, `entry`	an application leaf, one per bound input role, after the attempt
`produced`	`application`, `role`, `entry`	an application leaf, one per output role, in the completion batch
`result`	`application`, `outcome`, `manifest`, `resolution`, `attestation`	an application leaf, once, closing the completion batch
`staged`	`application`	an artifact space, once, before its content fact
`justifies`	`assertion_id`, `group`, `premise`, `method`	a `declarations` space, one per premise
`relation`	`assertion_id`, `kind`, `target`	a `declarations` space

Text arguments are exact Ontos text values, so Journal's argument filters select them; a position is an int; metadata is a map of text pairs. The application argument of declaration, bound, produced, result and staged is the admission occurrence A, an entry value, or dawn.none.v1 — the atom alone — for a declaration a principal wrote itself with no hosted application. release and entry are occurrence reference values, so a filter on bound's third argument selects every application that consumed one occurrence; request, envelope, manifest, resolution and attestation are hash values. outcome is text, one of completed, failed or interrupted; kind is text, one of supersedes, challenges or withdraws. Several membership claims may hold as independent facts. The profile fixes the encoding of every argument and the request-identity domains; independent fixtures, not round trips, establish it.

Record provenance and retries

Journal supplies occurrence coordinates, origins and batch boundaries. It does not supply a publisher or an acceptance clock, so Dawn persists both in the record fact. publisher is the authenticated principal. accepted_at is Dawn's clock for the first admitted candidate that commits, never a Journal timestamp. request_id is derived from the authenticated publisher and the caller's operation ID, scoped to the exact destination journal (RequestID). request_digest covers the operation name, the destination identity and the normalized semantic request, including the caller's explicit precondition; it excludes transport proof bytes and server-generated values such as the acceptance clock (RequestDigest). The normalized semantic request of an operation is the canonical JSON of its request type as the caller sent it, and the operation name in the digest is the table name (publish, compose, provision_worker, retire_worker, create_campaign, assign). A reader after a fresh Dawn process reconstructs all of them from the fact alone; the requirements restate both identities independently of the service.

The shared record writer applies one protocol to publish, compose and every provisioning record:

Resolve and authorize the exact destination. Search its journal for the request identity at a pinned cutoff through every required page. An incomplete lookup is not absence; conflicting occurrences are a profile violation, never a reason to select one silently.
If found, validate the fact and the required retained payload, compare the semantic request digest and fields, and return the original occurrence and admission clock. Changed content under the same identity is idempotency_mismatch; unavailable recovery data is unavailable.
If absent, construct and retain the required payload once, choose the candidate's admission clock, and append the exact fact with a stable scoped Journal operation ID. An uncertain result is retried with identical fact bytes and the identical precondition; a new Dawn process searches before constructing another candidate.
On an append mismatch caused by a concurrent winner, refresh the selected cutoff and recover that winner: an equal semantic request returns the original result, a different request is refused. An implicit current-head precondition is never recomputed as a substitute for recovering an accepted result.

These rules add no Journal uniqueness predicate, publisher field or clock. They preserve caller-supplied optimistic concurrency and cover a lost acknowledgement followed by later writes to the same journal.

Reading rules

Content is the sole append entry of an artifact space whose predicate is content, selected by rule, never by position. A second such entry is a Dawn invariant violation, refused by the filtered read that precedes every declare.
The current record of a leaf is the last append entry with predicate record, never the raw head: a head can be a creation event elsewhere in the tree.
A declaration is found by a filtered read of the declarations space at a pinned cutoff, including every continuation. The same completeness rule applies to record request lookup; an incomplete lookup is not absence.
An occurrence reference is an EntryRef. An entry inside a batch is a valid reference but not a valid through cutoff; a reader uses the batch end or a pinned later head and selects the requested position.
Authorization resolves a submitted space or occurrence identity to its actual path and verifies the configured Journal root and Dawn world before applying path grants. A caller-supplied path is not evidence that an EntryRef belongs to that path; foreign roots and worlds never bypass read, declaration, evidence or compose authorization.

Authentication, authorization and admission

Every surface call carries a proof signed by its principal. Dawn checks key admissibility, the exact signing record, audience, freshness and replay protection, then proves a grant chain from the world's root for the actual operation and path. A request path maps to the Thesmos space ["dawn", <world>, <path segments…>]; a grant on a space covers its subtree.

Kind	Permits
`read`	Resolve, children, entries, get, fetch, snapshot, query, explain and subscribe within scope
`publish`	Retain bytes, create artifacts, publish records, compose views and apply tools within scope
`declare`	Append an attributed declaration to an artifact within scope
`provision`	Create projects, campaigns and worker spaces, issue grants, assign, retire and export

A declare grant is sufficient for the declaration write; it does not grant ordinary publishing, artifact replacement or adoption. Artifact and evidence reads must also be authorized. General publish cannot write an artifact space's content or declarations journal. This structural rule applies to every principal, including the root. A broader grant does not bypass record immutability.

A valid proof identifies the submitting key. Dawn records that authenticated publisher itself; a statement's own author labels are claims inside the statement. Acceptance records the authority Dawn checked. It does not certify independent authorship, the truth of a statement, or the reliability of its evidence. Journal is identity-blind: every guarantee this surface makes holds for facts that entered through Dawn and for no others.

The development profile uses a configured root key, expiring grants and replay protection. Production backend isolation, current-authority/revocation ordering and key-management requirements remain tracked in STATUS.md.

Artifact creation

create artifact accepts operation_id, an artifact path shaped projects/<project>/artifacts/<artifact>, and an already retained artifact. It needs publish at that path and an existing project. Dawn verifies that the content is retained, creates the artifact space, appends its one content fact with expected_cutoff 0, and creates the declarations child. The result is the artifact space, its content occurrence and its declarations space.

An artifact's interpretation must itself be retained: Dawn retains the descriptors of its own record profiles beside their payloads, and any other interpretation's descriptor is the caller's to retain, under whatever type, before create artifact names it. Unretained bytes or an unretained interpretation are unresolved, and nothing is created.

A retry with the same operation ID and request recovers the same outcome; a different operation cannot replace the content. Initialization is resumable: after an uncertain content append, Dawn recovers and validates the one content fact before ensuring the declarations child, and never appends a second content fact on restart. Clients must not treat an artifact space without a content fact as a created artifact.

Applications

An application is Dawn running a tool (decision 0005). apply accepts an operation_id, the leaf path projects/<project>/applications/<name>, the tool by logical name, an optional pinned release, inputs binding roles to occurrence references, the recipe as a JSON value, and wait. It needs publish on the project and read on every input occurrence. The tool must be one the world configures; the valuation must bind every role the tool's description requires and no role it does not declare. Each input is resolved to its actual path, authorized, and verified: a content occurrence's retained bytes must exist, a record occurrence's payload must verify. A foreign root or world is not_found; an unconfigured tool or an unbound required role is invalid; unretained material is unresolved.

Three identities order an application. The retry identity is the publisher, the retry key and the destination leaf, exactly as for every other record: the same operation_id under the same principal recovers the admitted application, and a different semantic request under that key is idempotency_mismatch. The application identity is A, the occurrence of the attempt fact heading the leaf's batch. The computation identity is the resolved release occurrence, the set of bound input occurrences and the recipe hash — the key a reuse looks up, and two applications with the same computation identity are the same computation. A reuse is reported as reused, naming an earlier application whose outputs answered this request; the new application is still admitted and its batch still records the attempt, the bounds and the result.

Dawn then retains the recipe, canonically, and the normalized request, and appends the leaf's admission. The normalization is dawn/normalization/1: the normalized request is the canonical JSON of the ApplicationRequest, with wait absent, the recipe canonicalized (RFC 8785, {} for absent), the inputs a map so order is irrelevant, and the release resolved to an occurrence before normalization. RequestDigest covers this normalized request, so toggling wait under one retry key replays. The admission fact is attempt(release, request, publisher, request_id, request_digest, accepted_at) at A: the release's content occurrence, the hash of the retained normalized request, and the attempt's admission provenance. With wait, the service holds the call up to its own bound and answers the terminal state if reached; otherwise the caller follows the leaf through entries or a subscription.

The run proceeds under Dawn alone. The tool receives exactly the prepared inputs, a staging destination that retains through Dawn's content adapter, and, when its description declares egress, a client confined to those hosts; it has no other access. On completion Dawn appends one bound fact per input role naming A and the bound occurrence, then one completion batch: one produced fact per output role naming the output's content occurrence, and one result fact — the seal — carrying the outcome, the retained output manifest, the retained resolution (or dawn.none.v1 when there is none) and the retained, service-signed seal envelope. An output artifact space an application creates opens with a staged(A) fact before its content fact; such an artifact is public only once A has a result with outcome completed whose manifest lists it, and until then it is staging material, not a created artifact. An advance for that space is delivered when it is staged, and the read answers not_found until the seal: an advance reports that a journal changed and does not promise the subscriber may read it; a read after an advance is authorized and resolved as any other, and a refusal there is the subscriber's to tolerate. A terminal attempt with outcome failed or interrupted carries the reason; no result is appended and nothing the tool staged is named. The batch answers "what consumed this occurrence" and "what did this tool produce" as filtered reads over a project's applications; no pointer is copied into an output artifact.

An attempt admitted by a Dawn process that ended before completing it is terminated as interrupted when next observed, and the caller submits a new operation ID: no application is ever completed by a process that did not run it. A request that fails validation or a contract check against the tool's accepts, yields or effects is recorded under the leaf as a signed refusal record of profile dawn/refusal/1, not admitted as an attempt; the caller is told the reason and the leaf keeps the record.

Tool releases. Each configured tool is an organizer tools/<name>; each configured release is an artifact space tools/<name>/releases/<digest> whose content fact is the release's dawn/tool/1 description — name, version, class, input and output roles, effects, whether it is deterministic, its egress, and its executable identity (the service binary's hash, the build revision and the canonical configuration hash). A pinned release names the release's content occurrence exactly; an absent one resolves to the newest configured release. The executable identity is part of the release digest, so a release whose binary or configuration changed is another release.

A describer's declarations carry the application argument of the declaration fact: the admission occurrence A of the hosted application that emitted the declaration, or dawn.none.v1 for a declaration a principal wrote itself. The relation fact carries supersession, challenge and withdrawal as kinds of one explicit relationship; justifies joins the premises that jointly justify an assertion. The describer's publication protocol — how a describer publishes through its application, the candidate-selection record, and how the selection is admitted — is not in this revision.

Intake is an application whose input role is bound to a record of profile dawn/acquisition-target/1: a locator, the publisher's expected hash when there is one, the expected source the hash was read from, and the interpretation the fetched bytes are retained under. The tool fetches through its confined client, retains, and refuses a mismatch against the expected hash as a failed application. Artifacts with no application are the world's roots: its configured tool releases, and material a principal retained and named through create artifact, which attests who retained it and nothing more.

Declarations and admission evidence

declare accepts:

Member	Meaning
`operation_id`	Stable identity for retries of this assertion request
`artifact`	The artifact space's path; Dawn selects its one content fact by rule
`subject`	Optional `space#local` subject; absent or empty means the artifact itself
`statement`	A JSON object carrying the assertion's domain-specific content
`evidence`	Optional exact occurrence references cited as support
`justifications`	Optional premises with a `group` and `method` that jointly justify the assertion
`relations`	Optional `{kind, target}` relationships to earlier declarations: `supersedes`, `challenges` or `withdraws`

Dawn resolves the artifact's content and every cited occurrence under the caller's read authority. The subject's shape is validated; interpreting a domain subject and assessing a statement's evidence are model or consumer responsibilities.

The retained envelope, a DeclarationRecord, keeps the shape judgment(actor, claimed_time, frame_ref, evidence, body): its assertion ID, the original request, the exact content artifact, the authenticated publisher and the admission. Admission binds the world, the root, the destination declarations space identity {root_id, space_id} and its path at admission, the retained frame manifest by digest, Dawn's admission-policy version dawn.declaration.admission.v2, the acceptance instant, the original request proof and grants, and request_body, the exact request bytes whose digest the publisher signed. The frame is retained in Bytes and named by digest: it pins the artifact's content reference, the cited evidence occurrences, the grants and proof relied on, and the policy version. The world is the storage scope, not the frame. Dawn signs the canonical envelope with admission.signature empty, prefixed by the policy name and one newline byte. The occurrence position the fact later takes is not signed.

The declaration fact names the assertion ID, the envelope's digest, the exact artifact, the subject, the publisher and the application: the admission occurrence A of the hosted application that emitted it, or dawn.none.v1 for a principal's own declaration. Assertion identity is allocated from the authenticated actor and operation ID before the append. A retry compares the semantic declaration while retaining the first envelope, admission time and exact signed proof; fresh transport proof never justifies constructing a second envelope. Recovery verifies the original signature, admission evidence, destination, artifact and repeated fact fields: missing required evidence is unavailable, inconsistent occurrences are a profile violation, and neither permits minting another assertion.

A verifier uses the expected world, trusted root, destination space and path, verifies the admission signature, the frame digest and the original request signature, and checks that the exact request bytes decode to the stored request. The portable verifier does not rerun Thesmos or prove that the occurrence is in a journal; trust in a root is supplied by the verifier. Verification shows what Dawn admitted for that request. It does not make the statement true.

Each declaration is one occurrence. A later correction creates a new declaration and names the earlier occurrence in a relation of kind supersedes, challenges or withdraws. The earlier declaration remains retrievable. Supersession targets must concern the same artifact and subject and belong to the same authenticated publisher; a worker cannot withdraw another worker's statement. A relation is an explicit relationship, not an overwrite or an automatic consumer decision. Justifications cite the premises a describer relied on, joined by a group and method, one fact per premise. Declaration IDs are independent of the subject's identity, so disagreeing statements coexist without competing for one global subject binding.

Views, query and explanation

compose publishes a view record with exact selections, rules and an interpretation_profile. Each selection is an EntryRef; the composer must be authorized to read each selection and publish the view. Views select individual declaration occurrences and inventory records. A selection references its original occurrence; composition does not move it, change its publisher or assert its content again.

query reads only the view's selected occurrences at the view's own occurrence. Declaration rows have identity assertion#<declaration-id> and expose the artifact, subject, statement, publisher, evidence and relation links, with the original occurrence. Read that occurrence to retrieve the complete signed envelope; Dawn verifies admission against the selected destination, expected world and trusted root before projecting a declaration. A selected view is an attributed choice of inputs; stored rules are not a general truth evaluator.

The query filter object is a conjunction of scope, key, key_prefix, identity (space#local), from (an exact occurrence) and where (top-level member values compared as canonical JSON). limit and cursor page records in selection then identity order. An unknown filter produces unknown with an explanation; no matching records produces known_empty; an incomplete or unsupported evaluation is never known_empty. When the selected occurrences define one identity differently and the view's rules do not choose between them, the outcome for that identity is ambiguous and every definition is returned; the surface reports the disagreement rather than resolving it. A view occurrence that is not a view record is unresolved. The assertion identity scope is reserved for the verified projection; an inventory record defining assertion#… is refused by query rather than presented as an admitted declaration.

explain identifies an assertion's defining declaration occurrence, the selection that adopted it and the selected occurrences that disagree within the requested view. Any required selection the reader cannot access makes the request denied; Dawn does not silently narrow a view. Removed with the contribution profile is any history-wide record binding (order 0002 R2): a record identity has no global owner, only occurrences.

Snapshots and exports

snapshot captures an explicit manifest of a scope (the world or a path) and its selected descendants to an optional depth, retains it in Bytes as canonical JSON and returns it with its digest. Its cutoffs are fixed selections of individual journals, not a simultaneous observation of the whole tree. Continuation and resubmission reuse that selection; hitting a bound is limit_exceeded, never a shortened success.

export follows the complete traversal of order 0002: for the scope and recursively for every selected child, capture the space's cutoff once, read its own journal through all pages, enumerate its children at that same cutoff and recurse. Every selected space, its cutoff and its child observation are retained exactly once, including the world, intermediate organizers and empty journals. The retained export manifest may be chunked in Bytes and need not fit one Journal manifest's 4,096-space or byte bound. The retained export is a manifest of profile dawn/export/1, {scope, complete, chunks}, naming its chunks by digest in traversal order; each chunk is {spaces: [{space, through, entries, children}]}, consecutive selected spaces with the cutoff each was captured at, their own journal prefix through that cutoff as entries, and their child observation at that cutoff, within one manifest's byte bound. The result reports the manifest, the chunks, the counts and the coverage. An empty page with a continuation is not completion; an unavailable page or a traversal limit leaves explicit incomplete coverage; resumption recaptures no selected prefix. Query is only an optimization when its complete selection covers the same prefixes. Referenced byte payloads are a separate retention obligation, and public export is not provider restoration.

Subscriptions

A subscription reports which journals under a scope advanced, so a consumer learns of a change instead of polling for it. It is carried by the socket alone (WS.md): a server-initiated frame is what that binding has and HTTP does not. Journal places subscriptions above its own contract and offers none, so this is Dawn's surface to provide, not a Journal gap (decision 0004, whose event shape decision 0006 replaces).

subscribe accepts a scope path — the empty path is the world, as it is for children, snapshot and export — and needs read on it. Its result names the subscription, the scope's space and an expiry, and nothing else: no cutoffs, because every event carries the cutoff of the journal it reports. From the instant the reply is written, every advance of every journal under the scope is delivered or reported as a gap. What happened before it is the caller's to read, and needs no help to locate: the caller reads each journal it cares about at the cutoff the read reports, and applies events after that. unsubscribe closes a subscription this connection opened; its authority is that ownership, never a path grant, because it confers and discloses nothing.

An event is a journal's advance. It names the space, with its path, and the committed cutoff the journal is now at — a cursor, never a fact. The subscriber reads (its last position, cutoff] of that journal through entries under its own read authority, so authorization stays on the read, an event cannot disclose a fact its receiver may not read, and the journal remains the single truth for what a fact says. A child space appearing under the scope is an advance of that child, from absent to its first cutoff, and of its parent, whose enumeration changed; both are delivered.

Advances of one journal supersede each other. Two advances of a journal are one fact: it is now at the later cutoff. An undelivered event for a journal is replaced by a newer one, never queued behind it, so a subscription holds at most one pending event per journal that changed, whatever the commit rate under its scope. A subscription over a space with a million descendants costs nothing to open and delivers at most one pending event per journal that moved.

An advance does not promise readability. It reports that a journal changed. A read after it is authorized and resolved exactly as any other read, and not_found or denied there is the subscriber's to tolerate — as it is for a journal beyond its grants, since routing matches the scope the subscriber proved read on and re-checks nothing in the subtree at delivery. A space that exists but is not yet readable still advances, and so does the organizer that gained it, because both journals changed; suppressing either would make a cutoff lie.

Order is per journal. Each event names a cutoff later than the last event for that journal. Journal provides no total order across spaces and no global snapshot, so this surface promises none: an event carries no world-wide sequence, because there is none to carry. A consumer that needs one coherent cross-space picture takes a snapshot.

A gap is the scope, when which journal moved was lost. The pending table is bounded by distinct journals; an advance arriving while it is full cannot be held by name, so the subscription records once that something under the scope moved and, after the table drains, reports a gap naming the scope. The subscriber re-reads the scope. That is the only thing a subscription can lose. Silence for a journal means it did not advance; an event names where it is; a gap says the scope moved somewhere and to look. Exactly as an incomplete lookup is never absence, a lost advance is never reported as no change.

Delivery is immediate. Dawn emits an event as it commits the append, and nothing polls: not a consumer, which is what the socket is for, and not Dawn itself. One Dawn process serves one world and is its only writer, so emission at commit is complete as well as instant; there is no interval to configure and no bounded-delay case to reason about.

A fact that did not enter through Dawn is not delivered. Journal is identity-blind, so another holder of Journal access can write into the subtree, and this surface's standing position already covers it: every guarantee here holds for facts that entered through Dawn and for no others. Subscription delivery is one of those guarantees. Were a second Dawn process ever to serve one world, the answer would be a change feed in Journal under order 0002, never a poll inside Dawn.

A subscription is authorized once, at open, and expires. The open is an ordinary authenticated call — one proof, one attempt, the replay cache unchanged — and the subscription ends at the earlier of the grant's validity end and the service's configured maximum, reported as expires_at and announced by a final closed frame. Events carry no proof of their own, which is why the open must expire: an unbounded subscription would be authority outliving the grant that created it. Renewal is a fresh subscribe with a fresh proof; the subscriber reads the scope's journals at their current cutoffs and continues from there, the same read it made on first sight.

A subscription is connection state and nothing else. It writes no fact, creates no space, appears in no export or snapshot, and leaves no trace when it ends. It is not evidence: citing something still means citing its occurrence, read and authorized as ever. Retained content needs no subscription, being immutable. There is no replay log and no backfill: Journal is the durable history, the subscriber owns its positions, and resumption is the subscriber's read.

Operations

All mutations carry an operation_id. Dawn derives request identity from the authenticated principal, so workers cannot claim each other's request IDs. Record attribution is supplied from that principal.

Verb	Input	Result
`resolve`	path	The space, or null when unoccupied
`children`	optional path, cutoff, cursor, limit	Readable children at a fixed cutoff; without a path, the world's
`entries`	path, after, cutoff, limit	The journal's entries over a fixed prefix, ascending, decoded under the profile
`get`	occurrence reference	One exact entry, read at a valid covering cutoff, with its space
`fetch`	path and the bytes' hash	Retained bytes the journal names, verified against the hash
`snapshot`	optional path, depth	A captured manifest retained in Bytes with its digest
`retain`	scope path, bytes, interpretation hash	The artifact; nothing is named yet
`create artifact`	operation ID, artifact path, retained artifact	The artifact space, its content occurrence and its declarations space
`declare`	operation ID, artifact path, optional subject, statement, evidence and supersession targets	The declaration occurrence with its retained signed envelope
`publish`	operation ID, leaf path, profile, record, expected cutoff	The record occurrence
`compose`	operation ID, view path, pinned selections, rules, interpretation profile, expected cutoff	The view's record occurrence
`apply`	operation ID, application path, tool, optional release, inputs by role, recipe, wait	The admitted attempt and its outcome; on completion the sealed result and the outputs by role
`query`	view occurrence, filters, cursor, limit	Records with source, provenance, outcome, coverage and limits
`explain`	view occurrence, assertion ID	Defining declaration, adopting selection and disagreement
`create project`	operation ID, label	The project space
`provision worker`	project, worker label, principal, permissions, validity end	The worker space, its state record, grants and workspace configuration
`retire worker`	project, worker	The retired state record; the space and its records remain
`create campaign`	project, campaign label	The campaign's state record
`assign`	campaign, worker, pinned inputs, intended outputs, brief, expected cutoff	The assignment record; grants no authority
`export`	optional path, cursor	The retained export manifest with coverage
`subscribe`	scope	The subscription, its scope and its expiry; from the reply on, each journal under the scope that advances is reported once with its new cutoff
`unsubscribe`	subscription	The closed subscription and what it delivered

Worker lifecycle state is published at workers/<worker>/state and requires provision on the project; the principal cannot change. Campaign state requires provision on its campaign and cannot change its project. An assignment requires an existing worker and resolvable pinned inputs; declared outputs are working material beneath that worker's space or a projects/<project>/artifacts/<artifact>/declarations destination in the same project, covered by the worker's declaration authority. The assignment itself never issues a grant.

Receipts, durability and uncertain outcomes

A replay returns the first admitted result. The same principal and operation ID with changed content is idempotency_mismatch. A fresh proof is required for each attempt; the operation ID and semantic request remain unchanged.

Record payloads, envelopes, frames and manifests are retained in Bytes before Journal appends the fact that names them. A failed append may leave unreferenced retained content. Journal commits each batch with its receipt atomically; multi-step provisioning or artifact creation can leave intermediate spaces and recovers through retry. An acknowledged append is committed under Journal's contract; durability across a Journal restart is the durable provider's guarantee (order 0002 D10), not this surface's.

Cancellation or a lost connection after dispatch leaves the caller uncertain. Resend the same operation ID and request to recover the result. Choosing another operation ID can create another occurrence. Read cancellation has no effect; an interrupted fetch must not be accepted as a complete verified object.

Limits and refusals

Journal's key grammar, position domain, page bounds (1..128, default 64), batch, manifest and continuation bounds apply. Dawn's label grammar is stricter than Journal's key grammar. Dawn accepts at most 64 MiB of JSON per record request, except declare, whose complete original request is limited to 16 MiB. Byte streams inherit Bytes' object limits. One connection holds at most 16 subscriptions; one subscription holds a pending advance for at most 4,096 distinct journals at once, past which the scope is reported as a gap. Exceeding the subscription bound is limit_exceeded; the pending bound is a gap, not a refusal, because the subscription is still working.

Canonical JSON follows RFC 8785 over finite IEEE 754 numbers. Invalid UTF-8, unpaired surrogates, duplicate object members, non-finite numbers and integer literals outside ±(2^53−1) are refused. Names are compared without Unicode normalization. Statement objects follow the same canonicalization rules.

Refusal	Meaning
`not_found`	The path, space, occurrence, record, file or operation is not here; a foreign root or an identity outside the world is not here for a reader of the world
`invalid`	A value outside its grammar, limit or structural rule: a parameter, a label, a cutoff inside a batch or in the future, a body the binding cannot decode strictly
`invalid_cursor`	A malformed cursor, or one of another enumeration, traversal or query
`unverified`	Invalid key, signature, audience, freshness or replay proof; the operation was not evaluated
`denied`	Required authority is absent; the refusal does not disclose target existence
`invalid record`	Invalid profile content or a fact that violates `dawn-facts-v2`, with the failing field
`unresolved`	Required exact content or occurrence cannot be resolved
`structural`	The requested path or profile violates Dawn's layout or protected-space rules
`exists` / `conflict`	A new operation collides with an existing key or an expected cutoff
`idempotency_mismatch`	An operation ID was reused for a different semantic request
`limit_exceeded`	A declared bound of a value, batch, page, manifest or continuation would be exceeded
`unavailable`	A backend, a selected journal or required recovery data cannot currently be served; never reported as absence

These thirteen codes are the refusal table both bindings carry. An internal failure is not a refusal: the bindings report it as internal (HTTP 500) and disclose nothing else. The transitional code not_implemented stays defined, and the bindings still map it, for an operation whose source is a stub naming its owning item in the details — and this revision is a seam, so apply answers it, naming applications/anchoring in the details. Every other verb of the table is implemented, the subscription rows added on 2026-09-17 included, and the requirements hold each of them to this contract rather than to a stub, the skipped application cases named with their lanes. STATUS.md states what is implemented and ACCEPTANCE.md dates what was measured.

Scope and maintenance

Scheduling, execution, review policy and consumer belief are outside the service. Dawn records claims, their admitted publisher and exact selections. It does not implement the meta-series membrane/cell kernel or turn shared spaces into endorsement. The Journal contract does not move for Dawn's sake: a gap is a Journal change under order 0002, not a Dawn workaround.

The documentation index identifies the owners of current contracts and the superseded design documents. Update this surface, affected types/table, bindings, clients and the public requirements together: the requirements are the executable form of this document, grouped by the operation lane that implements them, and a claim here without a case there is prose. Generated schemas and route-name checks cannot establish the guarantees described here.

HTTP.md

The dawn HTTP binding

Status: current binding of the 2026-09-19 development surface. Candidate verification and deployment evidence are in STATUS.md. It carries SURFACE.md without extending it: every route below is one verb of that surface, and no route adds meaning the surface does not have. Where the two disagree, the surface wins and this file is wrong. This is the primary binding; WS.md carries the same operations over a socket. Both implementations use one table, operations.json, which the drift tests hold to this document, to the surface and to the code; openapi.json is generated from the same table for tooling that reads OpenAPI, and is never the contract where it is silent.

Shape

Requests and responses are JSON (application/json), except retain, whose request body is the bytes themselves, and fetch, whose response body is the bytes. Publishing and provisioning verbs are POST with a JSON object body; reads are GET with query parameters; query and explain are POST with a JSON body because their filters are structured. Records are returned exactly as the surface defines them, so a client can decode them into the types of nightforge.lab/ulab-dawn/api.

Native routes are relative to the operations listener root. Deployment mounts that listener under /api/operations/ and strips /api/operations before forwarding; clients use the complete external base URL, such as https://dawn.example/api/operations. The independent management listener is mounted under /api/management/, as required by the shared management contract. These deployment prefixes are not native service routes. Application routes live under /v1/; the operational routes of OPERATIONS.md live at the root and are not versioned. The service's name is dawn, with no version, and every response carries two headers:

Ulab-Service: dawn
Ulab-Contract: 2026-09-19

Ulab-Contract is the date on the surface's status line. A client treats a response without Ulab-Service: dawn as a protocol error, before reading its body, whatever its status.

Authentication carriage

Every route under /v1/ is a surface call and carries the principal's proof and grants in one header:

Dawn-Auth: <base64 of the JSON Carriage {"proof": {...}, "grants": [...]}>

The proof signs the signing record of the call, encoded per RFC 8785: {"op", "params", "body_digest", "principal", "nonce", "timestamp", "audience"}, where op is the table name of the operation, params are the table parameters as a socket envelope carries them (strings, integers, arrays of strings; a path as an array), body_digest is the sha256: digest of the request body bytes, or of the empty string when there is none, and the other four are the proof's own members. The signature is Ed25519 over those bytes by the principal's key; the principal is ed25519:<64 lowercase hex> of the public key. The audience is the operations endpoint in its http(s) form, including its external path prefix and with no trailing slash, the same value over either binding; the SDK defaults to it. A proof is one attempt: a retry of a publishing verb carries a fresh proof and the same operation_id. What the service verifies, in order, is the surface's: possession of the key, the signing record rebuilt from what arrived, freshness and the replay cache, the audience, then a grant chain from the root for the grant kind the row's grant column names on its path (kind is the standard's operation kind: what the row does on the wire). A failed proof is unverified (401); a missing chain is denied (403); neither reveals whether the path exists.

The operational routes carry no Dawn-Auth; a header on them is ignored.

Routes

Verb of the surface	Kind	Route
livez	operational	`GET /livez`
health	operational	`GET /healthz`
describe	operational	`GET /describe`
describe file	operational	`GET /describe/{file}`
resolve	read	`GET /v1/resolve?path=…&path=…`
children	read	`GET /v1/children?path=…&through&cursor&limit`
entries	read	`GET /v1/entries?path=…&after&through&limit`
get	read	`GET /v1/get?root_id&space_id&position`
fetch	read	`GET /v1/fetch?path=…&bytes`
snapshot	read	`GET /v1/snapshot?path=…&depth`
retain	publish	`PUT /v1/retain?path=…&type` with the bytes as the body
publish	publish	`POST /v1/publish`
create artifact	publish	`POST /v1/artifacts`
declare	declare	`POST /v1/declarations`
compose	publish	`POST /v1/compose`
apply	publish	`POST /v1/applications`
query	read	`POST /v1/query`
explain	read	`POST /v1/explain`
create project	provision	`POST /v1/projects`
provision worker	provision	`POST /v1/workers`
retire worker	provision	`POST /v1/workers/retire`
create campaign	provision	`POST /v1/campaigns`
assign	provision	`POST /v1/assignments`
export	provision	`GET /v1/export?path=…&cursor`

The removed verbs have no route and no alias: /v1/fork, /v1/list, /v1/history and /v1/view are 404 not_found like any unknown route, and list, history and view are served as children, entries and snapshot.

A path is repeated path parameters, one label per occurrence, below the world, never a joined string, so no separator or escaping exists on the wire. children, snapshot and export without path select the world itself; an empty path= is invalid like every empty parameter. A parameter has one name in a query and in a socket envelope; the names, kinds and which are required are in the table. {file} in the describe route spans slashes, so schema/PublishRequest.schema.json is one file name.

Request rules

A JSON body is at most 64 MiB; beyond that the response is 413 with an invalid envelope. A retain body is bounded by the bytes service's per-object limit, which the surface inherits.
A declare request has an additional 16 MiB limit for its original body; exceeding it is invalid. The same limit applies through WebSocket.
Bodies are decoded strictly: unknown members, members named twice at any depth, and trailing data after the object are invalid.
A Content-Type other than application/json on a JSON route, or other than application/octet-stream on retain, is invalid; an absent one is accepted.
Query parameters are validated, not ignored: an unknown name, an empty value and a repeated singleton are each invalid. path is the only repeatable parameter. limit is an integer in 1..128; omitted or 0 is the default 64; 129 is invalid. through, after, position and depth are integers in Journal's position domain: negative is invalid, position 0 is invalid, after beyond through is invalid. through must be 0 or a committed batch boundary of the selected journal: a position inside a batch is a valid get reference and an invalid cutoff, and a cutoff beyond the head is invalid. A continuation of children or entries resends the through its first page reported; a cursor with a disagreeing through is invalid. Parameters are validated before the carriage is verified, so a malformed request is 400 even without a proof; the domain rules above are the operation's and follow verification.
Coordinates are authorized where they resolve. root_id and space_id outside their grammar are invalid; a position beyond the journal's head is not_found; a foreign root, an unknown space, the Journal root itself or any space outside the world is not_found for a caller who may read the world and denied for every other caller, so a refusal never discloses whether a foreign identity exists. The same rule applies to an EntryRef inside a body: a view, a selection, cited evidence.
through, after and cursor are read selectors and are refused on publishing and provisioning verbs, except export, whose cursor resumes an incomplete traversal.

Responses

Situation	Status
Read, a replayed publishing or provisioning verb, `retain`, `snapshot`, `export`	`200`
Accepted publishing or provisioning verb	`201`
`unverified`	`401`
`denied`	`403`
`not_found`	`404`
`exists`, `conflict`, `idempotency_mismatch`, `unresolved`	`409`
`invalid`, `invalid_cursor`, `invalid_record`, `structural`	`400`
`limit_exceeded`, or a body over the limit	`413`
`unavailable`	`503`
Method not allowed on a known route (with `Allow`)	`405`
An internal failure (`internal`), or an operation the transitional source has not implemented (`not_implemented`, naming its item)	`500`

A refusal body is {"error": <code>, "message": <text>, "details": {…}}. The code is the machine-readable fact; clients must not parse the message. The details carry what the surface promises: the expected and actual cutoffs for conflict, the offending field for invalid and invalid_record, the unresolved reference for unresolved, the colliding label for structural. denied and unverified carry no details about the path.

A 201 versus a replay's 200 is a convenience, not the contract: replayed in the body is the authority, because a proxy may rewrite a status.

Router-level failures use the same envelope: an unknown route is a 404 not_found, never HTML or plain text, and a path that is not already clean (.., //) is 404 too; the binding issues no canonical-path redirects.

Streams

fetch answers 200 application/octet-stream with Content-Length and the bytes, verified against the requested bytes hash before the stream completes: a mismatch closes the connection before the last byte, so a client that received a complete body received the right one. retain reads the request body to its end, hashes it, retains it in bytes and answers with the Artifact; an aborted body retains nothing. Cancellation of either is the client closing the connection; the service keeps nothing.

Operational routes

Per OPERATIONS.md: GET /livez answers the health envelope with empty checks and is never 503; GET /healthz answers it with two checks, journal and bytes, each the reachability and service identity of the backend Dawn consumes, 200 when both are ok and 503 otherwise; GET /describe answers the service's description with identity carrying the Journal root, the world's space and the Journal instance; GET /describe/{file} serves one committed contract file, verbatim, from the files embedded at build. build.revision and build.dirty come from the binary's build information, else from the link-time variables nightforge.lab/ulab-dawn/components/service/internal/buildinfo.Revision and .Dirty, else "unknown" and true.

Representative calls

These wire examples are schematic: the abbreviated hashes and <signed-carriage> must be replaced by actual retained values and a proof over the exact request bytes. They are not transcripts or deployment evidence. The worker guide supplies an executable CLI workflow.

Create an artifact. The parent project exists and the bytes are retained.

POST /v1/artifacts HTTP/1.1
Content-Type: application/json
Dawn-Auth: <signed-carriage>

{"operation_id":"artifact-1","path":["projects","demo","artifacts","source"],
 "artifact":{"bytes":"sha256:…","type":"sha256:…"}}

A successful 201 returns an ArtifactResult naming the artifact space, its content occurrence at position 1 and its declarations space. Retrying the same request recovers an interrupted creation.

Append a declaration. The caller has declare on that artifact and read on its content and every cited occurrence.

POST /v1/declarations HTTP/1.1
Content-Type: application/json
Dawn-Auth: <signed-carriage>

{"operation_id":"inspection-1",
 "artifact":["projects","demo","artifacts","source"],
 "statement":{"predicate":"inspection","finding":"The selected input was inspected."}}

A successful 201 returns a DeclareResult with the declaration occurrence in the artifact's declarations journal, its assertion ID and the envelope's digest. Fetching the envelope by that digest at the declarations path yields the DeclarationRecord: its request, statement, exact content, authenticated publisher and signed admission evidence, with the exact request-body bytes preserved separately from the decoded request.

Publish a record. The caller has publish at the leaf's path.

POST /v1/publish HTTP/1.1
Content-Type: application/json
Dawn-Auth: <signed-carriage>

{"operation_id":"note-1","path":["projects","demo","workers","w1","notes","first"],
 "profile":"dawn/inventory/1","record":{"records":{"fn#main":{"name":"main"}}}}

A successful 201 returns a PublishResult: the Record occurrence with its entry, profile, the hash of the record's canonical form, the metadata, the authenticated publisher, the request_id of this principal's operation scoped to the leaf, the request_digest of the normalized request and the accepted_at instant; space_created reports that this operation created the leaf. The same request again is 200 with replayed: true and the same occurrence, digest and instant; the same operation_id with other content is 409 idempotency_mismatch; a stale expected_cutoff is 409 conflict with the expected and actual cutoffs.

Recover an uncertain declaration. Resend the same semantic request and operation_id with a fresh carriage. A replay returns 200 and replayed: true, preserving the first occurrence and admission proof. A changed statement under the same operation ID is 409 idempotency_mismatch. A new correction uses another operation ID and an explicit relation occurrence.

Read the declaration's entry. Occurrences are read by reference:

GET /v1/get?root_id=rt_…&space_id=spc_…&position=1 HTTP/1.1
Dawn-Auth: <signed-carriage>

Refusals. An invalid proof is 401 unverified; missing declaration or read authority is 403 denied without disclosing existence. Generic POST /v1/publish cannot write an artifact space's content or declarations journal, even with a broad publish grant. A supersession target from another publisher is refused; no earlier declaration is changed.

WS.md

The dawn WebSocket binding

Status: current binding of the 2026-09-19 development surface, beside the HTTP binding. STATUS.md records candidate and deployment evidence. It carries the same surface, SURFACE.md, over one socket: every operation of operations.json marked ws is a message of the same name, with the same parameters, the same body, the same result and the same refusals as over HTTP. It adds no meaning to the surface: the two rows it alone carries, subscribe and unsubscribe, are the surface's own, and everything they deliver is defined there. Where this document and the surface disagree, the surface wins and this file is wrong.

A socket is not a session for calls, and it is the one binding that carries subscriptions. The service holds no call state per connection: a cutoff or cursor reported on one connection is valid on another, a receipt is recovered by operation ID exactly as over HTTP, and a publishing verb whose reply was lost is resolved by resending the same operation ID. A subscription is the one thing that is per-connection, and it is explicit: a client opens it by name with subscribe, every frame it causes names it, it expires on its own schedule, and it ends with its connection (decision 0004).

The correlation id below is not the operation ID and never enters a canonical form, and neither does a subscription id. A client may send the same operation ID twice on one socket (a retry after an unknown outcome) and matches each reply by its own correlation id. Authentication is per call: every envelope carries its own proof, because a proof is one attempt. A subscription is authorized once, by the proof on its subscribe, and expires with the grant that authorized it — which is why its frames carry no proof and why it cannot run forever.

Upgrade

GET /v1/ws with an HTTP upgrade. The client must offer the subprotocol dawn; that is how the service name travels. A socket accepted without it is closed at once with 1002 and the reason subprotocol dawn required. No origin check is made: authentication is the proof in every envelope, so an origin check would add nothing a browser could not forge by holding a key. The upgrade response carries Ulab-Service and Ulab-Contract like every HTTP response.

The route is relative to the operations listener. Under the standard deployment mount, the external upgrade URL is /api/operations/v1/ws; the proxy removes /api/operations before forwarding. The signing audience remains the complete HTTP(S) operations base URL, including /api/operations, as defined by the HTTP binding. Management has no WebSocket binding.

Frames

Text frames only, each one JSON object. A binary frame closes the socket with 1003. A frame from the client that is not an object with an id, or whose id is empty, closes the socket with 1007: without an id there is nothing to answer. Frames from the service are replies, which carry the id they answer, and subscription frames, which carry a subscription instead; a client sends neither. The read limit is the HTTP body limit, 64 MiB, plus envelope headroom; a larger frame closes the socket with 1009 as the library enforces it. retain and fetch, the two streams, are HTTP only and are refused here with invalid.

Calls and replies

{"id": "7", "op": "publish", "params": {}, "body": {…},
 "auth": {"proof": {…}, "grants": [{…}]}}

Member	Meaning
`id`	correlation id, chosen by the client, 1..128 characters, unique among the calls in flight on this connection; reusing an in-flight id is refused for that call, not the socket
`op`	an operation name of the table; an unknown one, the removed `fork`, `list`, `history` and `view` included, is `not_found` with the message `no such operation`
`params`	the operation's parameters by their table names; `string` kinds as JSON strings, `int` kinds as JSON integers, `strings` kinds (a path) as arrays of strings; an unknown name, a wrong kind (a path as one string, a quoted number) or an empty string is refused before the operation is evaluated, as `invalid`, or as `unverified` when what the binding parsed no longer matches the signed record; the coordinate and cutoff domain rules are HTTP.md's
`body`	the request, for operations with a request type; a body on another operation is `invalid`; decoded by the same strict rules as an HTTP body
`auth`	the Carriage, the same object the HTTP binding carries base64-encoded in `Dawn-Auth`: the proof over this call's signing record and the grants relied on; absent or malformed is `unverified`

The signing record of a socket call is the one HTTP.md defines, with op, params and the body exactly as the envelope carries them; the same bytes are signed on either binding, so a client signs once per call whichever transport it uses.

{"id": "7", "status": "created", "contract": "2026-09-19", "result": {…}}
{"id": "7", "status": "error", "contract": "2026-09-19", "error": {"error": "denied", "message": "…"}}

Every reply carries contract, the surface's status-line date; the subprotocol carries the service name. The operational routes of OPERATIONS.md are not messages: livez, health, describe and describe_file are served over HTTP only, and naming one here is refused with invalid.

`status`	Meaning	HTTP equivalent
`created`	an accepted publishing or provisioning verb	`201`
`ok`	a read, or a replayed verb (`replayed` is in the result)	`200`
`error`	a refusal; `error` carries the same envelope HTTP returns as a body, an internal failure (`internal`) or a transitional `not_implemented` included	`4xx`, `5xx`

Subscription frames

subscribe and unsubscribe are ordinary calls with ordinary replies. What is new is that the service also writes frames no call asked for. A frame with a subscription member and no id is one of these; a client that never subscribes never receives one.

{"subscription":"sub_…","contract":"2026-09-19","event":{"space":{…},"cutoff":41}}
{"subscription":"sub_…","contract":"2026-09-19","gap":{"space":{…}}}
{"subscription":"sub_…","contract":"2026-09-19","closed":{"reason":"expired","delivered":308}}

Member	Meaning
`event`	one journal's advance: the `space` with its path, and the committed `cutoff` it is now at. A cursor, never the fact: read `(your last position, cutoff]` with `entries`. Advances of one journal supersede each other, so at most one is pending per journal
`gap`	the scope: an advance arrived while the subscription's pending table was full, so which journal moved was not kept. Re-read the scope
`closed`	the subscription's last frame, with its `reason` (`expired`, `unsubscribed`, `shutdown`, `scope_unavailable`) and how many events it delivered. No further frame names it

Each event for one journal names a cutoff later than the last event for that journal; across journals no order is promised, because Journal has no total order to promise one from. These frames carry no id and no status, are never replies, and are never counted against MaxSocketInFlight — a subscription is not a call in flight. A client correlates them by subscription, and treats an unknown subscription as a frame for one it has already closed and may discard.

A subscription ends with its connection, with no notice to anyone. The next connection opens a fresh one and reads the scope's journals at their current cutoffs — the same read it made on first sight — because the subscriber owns its positions and the service keeps no replay log.

Ordering

Calls are processed concurrently. Replies may arrive in any order; a client correlates by id and must not assume the order it sent. Writes to one journal are still serialized by Journal, so the ordering guarantees of the surface are unchanged. At most 32 calls may be in flight on one connection (MaxSocketInFlight). The 33rd is refused with invalid and the message connection has too many calls in flight; the SDK keeps within the bound and never sees that refusal. Replies are written in completion order under one writer per connection; a client that stops reading stalls only its own connection's replies, and a write that does not complete within 30 seconds drops that reply.

Closing

Code	Sent when
`1000`	the client closed normally; the service echoes
`1001`	the service is shutting down; in-flight calls finish first, within the ten-second grace
`1002`	the subprotocol was not offered
`1003`	a binary frame arrived
`1007`	a text frame was not an envelope with an id
`1009`	a frame exceeded the read limit

After a lost connection a client learns nothing about calls in flight. It resends reads freely, and resends a publishing verb with the same operation ID and a fresh proof: the reply is either the original result with replayed: true or an ordinary evaluation. Nothing on the service side needs reconnecting to; the next connection is a new transport for the same surface.

Operations

Every row carried here holds the refusals, coordinate rules, record provenance, snapshots and recovery of SURFACE.md exactly as over HTTP; the requirements run every group over both bindings. Every row of the table marked ws is carried; the messages are resolve, children, entries, get, snapshot, publish, create_artifact, declare, compose, apply, query, explain, create_project, provision_worker, retire_worker, create_campaign, assign, export, subscribe and unsubscribe. The last two are carried here alone: they have no HTTP route, because the server-initiated frame they cause is what this binding has and HTTP does not. Their parameters, types and refusals are those of operations.json and are not repeated here; the bodies are identical to the HTTP binding's.

Schemas

schema/AcquisitionTarget.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "ExpectedHash": {
      "properties": {
        "algorithm": {
          "type": "string"
        },
        "hex": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "algorithm",
        "hex"
      ],
      "description": "ExpectedHash is a publisher's hash of material: its algorithm and lower-case hex digest."
    }
  },
  "properties": {
    "locator": {
      "type": "string"
    },
    "expected": {
      "oneOf": [
        {
          "$ref": "#/$defs/ExpectedHash"
        },
        {
          "type": "null"
        }
      ]
    },
    "expected_source": {
      "type": "string"
    },
    "type": {
      "type": "string"
    },
    "label": {
      "type": "string"
    }
  },
  "type": "object",
  "required": [
    "locator",
    "type"
  ],
  "title": "AcquisitionTarget",
  "description": "AcquisitionTarget is the payload of a dawn/acquisition-target/1 record: what an intake tool is to fetch."
}

schema/ApplicationRequest.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    }
  },
  "properties": {
    "tool": {
      "type": "string"
    },
    "release": {
      "$ref": "#/$defs/EntryRef"
    },
    "inputs": {
      "additionalProperties": {
        "$ref": "#/$defs/EntryRef"
      },
      "type": "object"
    },
    "recipe": true,
    "normalization": {
      "type": "string"
    }
  },
  "type": "object",
  "required": [
    "tool",
    "release",
    "inputs",
    "recipe",
    "normalization"
  ],
  "title": "ApplicationRequest",
  "description": "ApplicationRequest is the retained normalized request: the tool as resolved, the release occurrence, the bound inputs and the canonicalized recipe."
}

schema/ApplyRequest.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    },
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    }
  },
  "properties": {
    "operation_id": {
      "type": "string"
    },
    "path": {
      "$ref": "#/$defs/Path"
    },
    "tool": {
      "type": "string"
    },
    "release": {
      "oneOf": [
        {
          "$ref": "#/$defs/EntryRef"
        },
        {
          "type": "null"
        }
      ]
    },
    "inputs": {
      "additionalProperties": {
        "$ref": "#/$defs/EntryRef"
      },
      "type": "object"
    },
    "recipe": true,
    "wait": {
      "type": "boolean"
    }
  },
  "type": "object",
  "required": [
    "operation_id",
    "path",
    "tool",
    "inputs",
    "recipe"
  ],
  "title": "ApplyRequest",
  "description": "ApplyRequest asks Dawn to run a configured tool on a valuation and record the application at path, a leaf under a project's applications."
}

schema/ApplyResult.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Artifact": {
      "properties": {
        "bytes": {
          "type": "string"
        },
        "type": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "bytes",
        "type"
      ],
      "description": "Artifact is exact retained content with a selected interpretation: the hash of the bytes and the hash of the interpretation descriptor the bytes are read under (order 0002 D4)."
    },
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    }
  },
  "properties": {
    "attempt": {
      "$ref": "#/$defs/EntryRef"
    },
    "release": {
      "$ref": "#/$defs/EntryRef"
    },
    "outcome": {
      "type": "string"
    },
    "result": {
      "oneOf": [
        {
          "$ref": "#/$defs/EntryRef"
        },
        {
          "type": "null"
        }
      ]
    },
    "outputs": {
      "additionalProperties": {
        "$ref": "#/$defs/Artifact"
      },
      "type": "object"
    },
    "reason": {
      "type": "string"
    },
    "replayed": {
      "type": "boolean"
    },
    "reused": {
      "oneOf": [
        {
          "$ref": "#/$defs/EntryRef"
        },
        {
          "type": "null"
        }
      ]
    }
  },
  "type": "object",
  "required": [
    "attempt",
    "release",
    "outcome",
    "replayed"
  ],
  "title": "ApplyResult",
  "description": "ApplyResult is the admitted attempt and where it stands: the attempt's occurrence A; the release occurrence that ran; the outcome; on completion the result's head occurrence and its outputs by role; on failure the reason."
}

schema/ArtifactResult.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Artifact": {
      "properties": {
        "bytes": {
          "type": "string"
        },
        "type": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "bytes",
        "type"
      ],
      "description": "Artifact is exact retained content with a selected interpretation: the hash of the bytes and the hash of the interpretation descriptor the bytes are read under (order 0002 D4)."
    },
    "Content": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "artifact": {
          "$ref": "#/$defs/Artifact"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "artifact"
      ],
      "description": "Content is the one content occurrence of an artifact space."
    },
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    },
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    },
    "Space": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "path": {
          "$ref": "#/$defs/Path"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "path"
      ],
      "description": "Space is a space's identity together with its Dawn path: the labels below the world, so a grant by path applies to it."
    }
  },
  "properties": {
    "space": {
      "$ref": "#/$defs/Space"
    },
    "content": {
      "$ref": "#/$defs/Content"
    },
    "declarations": {
      "$ref": "#/$defs/Space"
    },
    "replayed": {
      "type": "boolean"
    }
  },
  "type": "object",
  "required": [
    "space",
    "content",
    "declarations",
    "replayed"
  ],
  "title": "ArtifactResult",
  "description": "ArtifactResult is the artifact space, its one content occurrence and its declarations space, created or recovered."
}

schema/AssignRequest.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    },
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    }
  },
  "properties": {
    "operation_id": {
      "type": "string"
    },
    "campaign": {
      "type": "string"
    },
    "assignment": {
      "type": "string"
    },
    "expected_cutoff": {
      "oneOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ]
    },
    "worker": {
      "type": "string"
    },
    "inputs": {
      "items": {
        "$ref": "#/$defs/EntryRef"
      },
      "type": "array"
    },
    "outputs": {
      "items": {
        "$ref": "#/$defs/Path"
      },
      "type": "array"
    },
    "brief": {
      "type": "string"
    }
  },
  "type": "object",
  "required": [
    "operation_id",
    "campaign",
    "assignment",
    "worker",
    "inputs",
    "outputs"
  ],
  "title": "AssignRequest",
  "description": "AssignRequest publishes an assignment: pinned input occurrences, intended outputs under the worker's space or an artifact's declarations, and the brief the worker's session starts from."
}

schema/Carriage.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Grant": {
      "properties": {
        "principal": {
          "type": "string"
        },
        "kind": {
          "type": "string"
        },
        "path": {
          "$ref": "#/$defs/Path"
        },
        "valid_until": {
          "type": "string"
        },
        "issuer": {
          "type": "string"
        },
        "signature": {
          "type": "string",
          "description": "base64 of the 64 Ed25519 signature bytes over the fact"
        }
      },
      "type": "object",
      "required": [
        "principal",
        "kind",
        "path",
        "valid_until",
        "issuer",
        "signature"
      ],
      "description": "Grant is what a principal carries to prove it may act: a kind on a subtree until an instant, issued by another principal (the root or a delegate)."
    },
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    },
    "Proof": {
      "properties": {
        "principal": {
          "type": "string"
        },
        "nonce": {
          "type": "string"
        },
        "timestamp": {
          "type": "string"
        },
        "audience": {
          "type": "string"
        },
        "signature": {
          "type": "string",
          "description": "base64 of the 64 Ed25519 signature bytes"
        }
      },
      "type": "object",
      "required": [
        "principal",
        "nonce",
        "timestamp",
        "audience",
        "signature"
      ],
      "description": "Proof authenticates one request attempt: the principal, a fresh nonce, the instant, the audience the proof is meant for, and the signature over the signing record."
    }
  },
  "properties": {
    "proof": {
      "$ref": "#/$defs/Proof"
    },
    "grants": {
      "items": {
        "$ref": "#/$defs/Grant"
      },
      "type": "array"
    }
  },
  "type": "object",
  "required": [
    "proof",
    "grants"
  ],
  "title": "Carriage",
  "description": "Carriage is the proof and the grants a request carries."
}

schema/ChildrenPage.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Child": {
      "properties": {
        "key": {
          "type": "string"
        },
        "space": {
          "$ref": "#/$defs/Space"
        },
        "created_at": {
          "$ref": "#/$defs/EntryRef"
        }
      },
      "type": "object",
      "required": [
        "key",
        "space",
        "created_at"
      ],
      "description": "Child is one child of a space at the parent's selected cutoff, with the creation entry that recorded it: Journal's own child observation."
    },
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    },
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    },
    "Space": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "path": {
          "$ref": "#/$defs/Path"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "path"
      ],
      "description": "Space is a space's identity together with its Dawn path: the labels below the world, so a grant by path applies to it."
    }
  },
  "properties": {
    "space": {
      "$ref": "#/$defs/Space"
    },
    "through": {
      "type": "integer"
    },
    "children": {
      "items": {
        "$ref": "#/$defs/Child"
      },
      "type": "array"
    },
    "next_cursor": {
      "oneOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    }
  },
  "type": "object",
  "required": [
    "space",
    "through",
    "children"
  ],
  "title": "ChildrenPage",
  "description": "ChildrenPage is one page of a space's readable children at a fixed cutoff."
}

schema/ComposeRequest.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    },
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    }
  },
  "properties": {
    "operation_id": {
      "type": "string"
    },
    "path": {
      "$ref": "#/$defs/Path"
    },
    "expected_cutoff": {
      "oneOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ]
    },
    "selections": {
      "items": {
        "$ref": "#/$defs/EntryRef"
      },
      "type": "array"
    },
    "rules": true,
    "interpretation_profile": {
      "type": "string"
    },
    "metadata": {
      "additionalProperties": {
        "type": "string"
      },
      "type": "object"
    }
  },
  "type": "object",
  "required": [
    "operation_id",
    "path",
    "selections",
    "rules",
    "interpretation_profile"
  ],
  "title": "ComposeRequest",
  "description": "ComposeRequest composes a view from exact occurrence selections and publishes it as a record under views/."
}

schema/CreateArtifactRequest.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Artifact": {
      "properties": {
        "bytes": {
          "type": "string"
        },
        "type": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "bytes",
        "type"
      ],
      "description": "Artifact is exact retained content with a selected interpretation: the hash of the bytes and the hash of the interpretation descriptor the bytes are read under (order 0002 D4)."
    },
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    }
  },
  "properties": {
    "operation_id": {
      "type": "string"
    },
    "path": {
      "$ref": "#/$defs/Path"
    },
    "artifact": {
      "$ref": "#/$defs/Artifact"
    }
  },
  "type": "object",
  "required": [
    "operation_id",
    "path",
    "artifact"
  ],
  "title": "CreateArtifactRequest",
  "description": "CreateArtifactRequest creates an artifact space at projects/\u003cproject\u003e/artifacts/\u003clabel\u003e with exactly one content fact naming already retained content, and its declarations space."
}

schema/CreateCampaignRequest.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "operation_id": {
      "type": "string"
    },
    "label": {
      "type": "string"
    },
    "project": {
      "type": "string"
    }
  },
  "type": "object",
  "required": [
    "operation_id",
    "label",
    "project"
  ],
  "title": "CreateCampaignRequest",
  "description": "CreateCampaignRequest creates a campaign space over a project."
}

schema/CreateProjectRequest.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "operation_id": {
      "type": "string"
    },
    "label": {
      "type": "string"
    }
  },
  "type": "object",
  "required": [
    "operation_id",
    "label"
  ],
  "title": "CreateProjectRequest",
  "description": "CreateProjectRequest creates a project space with its organizing spaces."
}

schema/Declaration.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Artifact": {
      "properties": {
        "bytes": {
          "type": "string"
        },
        "type": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "bytes",
        "type"
      ],
      "description": "Artifact is exact retained content with a selected interpretation: the hash of the bytes and the hash of the interpretation descriptor the bytes are read under (order 0002 D4)."
    },
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    }
  },
  "properties": {
    "entry": {
      "$ref": "#/$defs/EntryRef"
    },
    "assertion_id": {
      "type": "string"
    },
    "envelope": {
      "type": "string"
    },
    "artifact": {
      "$ref": "#/$defs/Artifact"
    },
    "subject": {
      "type": "string"
    },
    "publisher": {
      "type": "string"
    },
    "application": {
      "oneOf": [
        {
          "$ref": "#/$defs/EntryRef"
        },
        {
          "type": "null"
        }
      ]
    }
  },
  "type": "object",
  "required": [
    "entry",
    "assertion_id",
    "envelope",
    "artifact",
    "publisher"
  ],
  "title": "Declaration",
  "description": "Declaration is one admitted declaration occurrence: the fact in an artifact's declarations journal."
}

schema/DeclarationFrame.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Artifact": {
      "properties": {
        "bytes": {
          "type": "string"
        },
        "type": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "bytes",
        "type"
      ],
      "description": "Artifact is exact retained content with a selected interpretation: the hash of the bytes and the hash of the interpretation descriptor the bytes are read under (order 0002 D4)."
    },
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    },
    "Grant": {
      "properties": {
        "principal": {
          "type": "string"
        },
        "kind": {
          "type": "string"
        },
        "path": {
          "$ref": "#/$defs/Path"
        },
        "valid_until": {
          "type": "string"
        },
        "issuer": {
          "type": "string"
        },
        "signature": {
          "type": "string",
          "description": "base64 of the 64 Ed25519 signature bytes over the fact"
        }
      },
      "type": "object",
      "required": [
        "principal",
        "kind",
        "path",
        "valid_until",
        "issuer",
        "signature"
      ],
      "description": "Grant is what a principal carries to prove it may act: a kind on a subtree until an instant, issued by another principal (the root or a delegate)."
    },
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    },
    "Proof": {
      "properties": {
        "principal": {
          "type": "string"
        },
        "nonce": {
          "type": "string"
        },
        "timestamp": {
          "type": "string"
        },
        "audience": {
          "type": "string"
        },
        "signature": {
          "type": "string",
          "description": "base64 of the 64 Ed25519 signature bytes"
        }
      },
      "type": "object",
      "required": [
        "principal",
        "nonce",
        "timestamp",
        "audience",
        "signature"
      ],
      "description": "Proof authenticates one request attempt: the principal, a fresh nonce, the instant, the audience the proof is meant for, and the signature over the signing record."
    }
  },
  "properties": {
    "policy": {
      "type": "string"
    },
    "content": {
      "$ref": "#/$defs/Artifact"
    },
    "evidence": {
      "items": {
        "$ref": "#/$defs/EntryRef"
      },
      "type": "array"
    },
    "grants": {
      "items": {
        "$ref": "#/$defs/Grant"
      },
      "type": "array"
    },
    "proof": {
      "$ref": "#/$defs/Proof"
    }
  },
  "type": "object",
  "required": [
    "policy",
    "content",
    "evidence",
    "grants",
    "proof"
  ],
  "title": "DeclarationFrame",
  "description": "DeclarationFrame is what the act was made against, retained in Bytes as canonical JSON and named by digest in the admission: the artifact's content reference, the cited evidence occurrences, the grants and proof relied on, and Dawn's admission-policy version."
}

schema/DeclarationRecord.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Artifact": {
      "properties": {
        "bytes": {
          "type": "string"
        },
        "type": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "bytes",
        "type"
      ],
      "description": "Artifact is exact retained content with a selected interpretation: the hash of the bytes and the hash of the interpretation descriptor the bytes are read under (order 0002 D4)."
    },
    "Carriage": {
      "properties": {
        "proof": {
          "$ref": "#/$defs/Proof"
        },
        "grants": {
          "items": {
            "$ref": "#/$defs/Grant"
          },
          "type": "array"
        }
      },
      "type": "object",
      "required": [
        "proof",
        "grants"
      ],
      "description": "Carriage is the proof and the grants a request carries."
    },
    "DeclarationAdmission": {
      "properties": {
        "world": {
          "type": "string"
        },
        "root": {
          "type": "string"
        },
        "space": {
          "$ref": "#/$defs/SpaceRef"
        },
        "path": {
          "$ref": "#/$defs/Path"
        },
        "frame": {
          "type": "string"
        },
        "policy": {
          "type": "string"
        },
        "accepted_at": {
          "type": "string"
        },
        "auth": {
          "$ref": "#/$defs/Carriage"
        },
        "request_body": {
          "type": "string",
          "contentEncoding": "base64"
        },
        "signature": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "world",
        "root",
        "space",
        "path",
        "frame",
        "policy",
        "accepted_at",
        "auth",
        "request_body",
        "signature"
      ],
      "description": "DeclarationAdmission records the world, root, exact destination space and its path at admission, the retained frame manifest, Dawn's admission policy, the accepted instant, the worker's request proof and grants, and the root's signature."
    },
    "DeclareRequest": {
      "properties": {
        "operation_id": {
          "type": "string"
        },
        "artifact": {
          "$ref": "#/$defs/Path"
        },
        "subject": {
          "type": "string"
        },
        "statement": true,
        "evidence": {
          "items": {
            "$ref": "#/$defs/EntryRef"
          },
          "type": "array"
        },
        "justifications": {
          "items": {
            "$ref": "#/$defs/Justification"
          },
          "type": "array"
        },
        "relations": {
          "items": {
            "$ref": "#/$defs/Relation"
          },
          "type": "array"
        }
      },
      "type": "object",
      "required": [
        "operation_id",
        "artifact",
        "statement"
      ],
      "description": "DeclareRequest adds one immutable assertion about an artifact's exact content."
    },
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    },
    "Grant": {
      "properties": {
        "principal": {
          "type": "string"
        },
        "kind": {
          "type": "string"
        },
        "path": {
          "$ref": "#/$defs/Path"
        },
        "valid_until": {
          "type": "string"
        },
        "issuer": {
          "type": "string"
        },
        "signature": {
          "type": "string",
          "description": "base64 of the 64 Ed25519 signature bytes over the fact"
        }
      },
      "type": "object",
      "required": [
        "principal",
        "kind",
        "path",
        "valid_until",
        "issuer",
        "signature"
      ],
      "description": "Grant is what a principal carries to prove it may act: a kind on a subtree until an instant, issued by another principal (the root or a delegate)."
    },
    "Justification": {
      "properties": {
        "group": {
          "type": "string"
        },
        "premises": {
          "items": {
            "$ref": "#/$defs/EntryRef"
          },
          "type": "array"
        },
        "method": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "group",
        "premises",
        "method"
      ],
      "description": "Justification joins a group of premises that jointly justify a declaration: each premise becomes one justifies fact, and the group id joins them."
    },
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    },
    "Proof": {
      "properties": {
        "principal": {
          "type": "string"
        },
        "nonce": {
          "type": "string"
        },
        "timestamp": {
          "type": "string"
        },
        "audience": {
          "type": "string"
        },
        "signature": {
          "type": "string",
          "description": "base64 of the 64 Ed25519 signature bytes"
        }
      },
      "type": "object",
      "required": [
        "principal",
        "nonce",
        "timestamp",
        "audience",
        "signature"
      ],
      "description": "Proof authenticates one request attempt: the principal, a fresh nonce, the instant, the audience the proof is meant for, and the signature over the signing record."
    },
    "Relation": {
      "properties": {
        "kind": {
          "type": "string"
        },
        "target": {
          "$ref": "#/$defs/EntryRef"
        }
      },
      "type": "object",
      "required": [
        "kind",
        "target"
      ],
      "description": "Relation names a declaration's relation to another occurrence: supersedes, challenges or withdraws."
    },
    "SpaceRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id"
      ],
      "description": "SpaceRef is the exact identity of one space and its journal, as Journal allocated it."
    }
  },
  "properties": {
    "id": {
      "type": "string"
    },
    "request": {
      "$ref": "#/$defs/DeclareRequest"
    },
    "content": {
      "$ref": "#/$defs/Artifact"
    },
    "publisher": {
      "type": "string"
    },
    "admission": {
      "$ref": "#/$defs/DeclarationAdmission"
    }
  },
  "type": "object",
  "required": [
    "id",
    "request",
    "content",
    "publisher",
    "admission"
  ],
  "title": "DeclarationRecord",
  "description": "DeclarationRecord is the retained envelope of one declaration: the worker's assertion and Dawn's authenticated admission, retained in Bytes and named by its digest in the declaration fact."
}

schema/DeclareRequest.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    },
    "Justification": {
      "properties": {
        "group": {
          "type": "string"
        },
        "premises": {
          "items": {
            "$ref": "#/$defs/EntryRef"
          },
          "type": "array"
        },
        "method": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "group",
        "premises",
        "method"
      ],
      "description": "Justification joins a group of premises that jointly justify a declaration: each premise becomes one justifies fact, and the group id joins them."
    },
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    },
    "Relation": {
      "properties": {
        "kind": {
          "type": "string"
        },
        "target": {
          "$ref": "#/$defs/EntryRef"
        }
      },
      "type": "object",
      "required": [
        "kind",
        "target"
      ],
      "description": "Relation names a declaration's relation to another occurrence: supersedes, challenges or withdraws."
    }
  },
  "properties": {
    "operation_id": {
      "type": "string"
    },
    "artifact": {
      "$ref": "#/$defs/Path"
    },
    "subject": {
      "type": "string"
    },
    "statement": true,
    "evidence": {
      "items": {
        "$ref": "#/$defs/EntryRef"
      },
      "type": "array"
    },
    "justifications": {
      "items": {
        "$ref": "#/$defs/Justification"
      },
      "type": "array"
    },
    "relations": {
      "items": {
        "$ref": "#/$defs/Relation"
      },
      "type": "array"
    }
  },
  "type": "object",
  "required": [
    "operation_id",
    "artifact",
    "statement"
  ],
  "title": "DeclareRequest",
  "description": "DeclareRequest adds one immutable assertion about an artifact's exact content."
}

schema/DeclareResult.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Artifact": {
      "properties": {
        "bytes": {
          "type": "string"
        },
        "type": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "bytes",
        "type"
      ],
      "description": "Artifact is exact retained content with a selected interpretation: the hash of the bytes and the hash of the interpretation descriptor the bytes are read under (order 0002 D4)."
    },
    "Declaration": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "assertion_id": {
          "type": "string"
        },
        "envelope": {
          "type": "string"
        },
        "artifact": {
          "$ref": "#/$defs/Artifact"
        },
        "subject": {
          "type": "string"
        },
        "publisher": {
          "type": "string"
        },
        "application": {
          "oneOf": [
            {
              "$ref": "#/$defs/EntryRef"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "type": "object",
      "required": [
        "entry",
        "assertion_id",
        "envelope",
        "artifact",
        "publisher"
      ],
      "description": "Declaration is one admitted declaration occurrence: the fact in an artifact's declarations journal."
    },
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    }
  },
  "properties": {
    "declaration": {
      "$ref": "#/$defs/Declaration"
    },
    "replayed": {
      "type": "boolean"
    }
  },
  "type": "object",
  "required": [
    "declaration",
    "replayed"
  ],
  "title": "DeclareResult",
  "description": "DeclareResult is the admitted declaration occurrence, or the first admission recovered for a retry of the same semantic request."
}

schema/Describe.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "BindingHTTP": {
      "properties": {
        "prefix": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "prefix"
      ],
      "description": "BindingHTTP describes the HTTP binding in the describe document."
    },
    "BindingWS": {
      "properties": {
        "path": {
          "type": "string"
        },
        "subprotocol": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "path",
        "subprotocol"
      ],
      "description": "BindingWS describes the socket binding."
    },
    "Bindings": {
      "properties": {
        "primary": {
          "type": "string"
        },
        "http": {
          "oneOf": [
            {
              "$ref": "#/$defs/BindingHTTP"
            },
            {
              "type": "null"
            }
          ]
        },
        "ws": {
          "oneOf": [
            {
              "$ref": "#/$defs/BindingWS"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "type": "object",
      "required": [
        "primary"
      ],
      "description": "Bindings names the primary binding and describes each offered one."
    },
    "Build": {
      "properties": {
        "revision": {
          "type": "string"
        },
        "dirty": {
          "type": "boolean"
        },
        "go": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "revision",
        "dirty",
        "go"
      ],
      "description": "Build identifies the binary."
    },
    "HTTPBinding": {
      "properties": {
        "method": {
          "type": "string"
        },
        "path": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "method",
        "path"
      ],
      "description": "HTTPBinding carries an operation as one request and one response."
    },
    "Identity": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "world_space_id": {
          "type": "string"
        },
        "journal_instance_id": {
          "type": "string"
        },
        "world": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "world_space_id",
        "journal_instance_id"
      ],
      "description": "Identity is the service-specific identity member: the Journal root the world lives in, the world's own space, the Journal instance and the world's name, the space its grants are placed in."
    },
    "Operation": {
      "properties": {
        "name": {
          "type": "string"
        },
        "kind": {
          "type": "string",
          "description": "mutation | read | stream | session | operational: the standard's operation kind"
        },
        "grant": {
          "type": "string",
          "description": "read | publish | declare | provision: the grant kind the operation needs; empty for operational rows"
        },
        "doc": {
          "type": "string"
        },
        "params": {
          "items": {
            "$ref": "#/$defs/Param"
          },
          "type": "array"
        },
        "request": {
          "type": "string",
          "description": "body type; \"bytes\" for a raw stream"
        },
        "response": {
          "type": "string",
          "description": "result type; \"bytes\" for a raw stream; empty for a served file"
        },
        "errors": {
          "items": {
            "type": "string"
          },
          "type": "array",
          "description": "refusals beyond invalid, unverified and denied"
        },
        "http": {
          "$ref": "#/$defs/HTTPBinding"
        },
        "ws": {
          "type": "boolean",
          "description": "carried by the socket as a message of the same name; streams and operational rows are HTTP only"
        }
      },
      "type": "object",
      "required": [
        "name",
        "kind",
        "doc",
        "params",
        "errors",
        "ws"
      ],
      "description": "Operation is one row of the table."
    },
    "Param": {
      "properties": {
        "name": {
          "type": "string"
        },
        "kind": {
          "type": "string"
        },
        "required": {
          "type": "boolean"
        },
        "doc": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "name",
        "kind",
        "required",
        "doc"
      ],
      "description": "Param is one named input of an operation, outside its body."
    },
    "Refusal": {
      "properties": {
        "name": {
          "type": "string"
        },
        "http": {
          "type": "integer"
        },
        "meaning": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "name",
        "http",
        "meaning"
      ],
      "description": "Refusal is one row of the refusal table."
    }
  },
  "properties": {
    "service": {
      "type": "string"
    },
    "contract": {
      "type": "string"
    },
    "build": {
      "$ref": "#/$defs/Build"
    },
    "identity": {
      "oneOf": [
        {
          "$ref": "#/$defs/Identity"
        },
        {
          "type": "null"
        }
      ]
    },
    "bindings": {
      "$ref": "#/$defs/Bindings"
    },
    "operations": {
      "items": {
        "$ref": "#/$defs/Operation"
      },
      "type": "array"
    },
    "refusals": {
      "items": {
        "$ref": "#/$defs/Refusal"
      },
      "type": "array"
    },
    "files": {
      "items": {
        "type": "string"
      },
      "type": "array"
    }
  },
  "type": "object",
  "required": [
    "service",
    "contract",
    "build",
    "bindings",
    "operations",
    "refusals",
    "files"
  ],
  "title": "Describe",
  "description": "Describe is the document of GET /describe."
}

schema/EntriesPage.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Artifact": {
      "properties": {
        "bytes": {
          "type": "string"
        },
        "type": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "bytes",
        "type"
      ],
      "description": "Artifact is exact retained content with a selected interpretation: the hash of the bytes and the hash of the interpretation descriptor the bytes are read under (order 0002 D4)."
    },
    "Attempt": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "release": {
          "$ref": "#/$defs/EntryRef"
        },
        "request": {
          "type": "string"
        },
        "publisher": {
          "type": "string"
        },
        "request_id": {
          "type": "string"
        },
        "request_digest": {
          "type": "string"
        },
        "accepted_at": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "release",
        "request",
        "publisher",
        "request_id",
        "request_digest",
        "accepted_at"
      ],
      "description": "Attempt is one admitted application's attempt fact: the release occurrence that ran, the retained normalized request by hash, and Dawn's admission provenance for the attempt."
    },
    "Batch": {
      "properties": {
        "first": {
          "type": "integer"
        },
        "last": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "first",
        "last"
      ],
      "description": "Batch is the committed batch an entry belongs to."
    },
    "Bound": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "application": {
          "$ref": "#/$defs/EntryRef"
        },
        "role": {
          "type": "string"
        },
        "bound": {
          "$ref": "#/$defs/EntryRef"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "application",
        "role",
        "bound"
      ],
      "description": "Bound is one input role of the application named by application, bound to one occurrence."
    },
    "Child": {
      "properties": {
        "key": {
          "type": "string"
        },
        "space": {
          "$ref": "#/$defs/Space"
        },
        "created_at": {
          "$ref": "#/$defs/EntryRef"
        }
      },
      "type": "object",
      "required": [
        "key",
        "space",
        "created_at"
      ],
      "description": "Child is one child of a space at the parent's selected cutoff, with the creation entry that recorded it: Journal's own child observation."
    },
    "Declaration": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "assertion_id": {
          "type": "string"
        },
        "envelope": {
          "type": "string"
        },
        "artifact": {
          "$ref": "#/$defs/Artifact"
        },
        "subject": {
          "type": "string"
        },
        "publisher": {
          "type": "string"
        },
        "application": {
          "oneOf": [
            {
              "$ref": "#/$defs/EntryRef"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "type": "object",
      "required": [
        "entry",
        "assertion_id",
        "envelope",
        "artifact",
        "publisher"
      ],
      "description": "Declaration is one admitted declaration occurrence: the fact in an artifact's declarations journal."
    },
    "Entry": {
      "properties": {
        "ref": {
          "$ref": "#/$defs/EntryRef"
        },
        "origin": {
          "type": "string"
        },
        "batch": {
          "$ref": "#/$defs/Batch"
        },
        "fact": {
          "type": "string",
          "contentEncoding": "base64"
        },
        "content": {
          "oneOf": [
            {
              "$ref": "#/$defs/Artifact"
            },
            {
              "type": "null"
            }
          ]
        },
        "declaration": {
          "oneOf": [
            {
              "$ref": "#/$defs/Declaration"
            },
            {
              "type": "null"
            }
          ]
        },
        "record": {
          "oneOf": [
            {
              "$ref": "#/$defs/Record"
            },
            {
              "type": "null"
            }
          ]
        },
        "attempt": {
          "oneOf": [
            {
              "$ref": "#/$defs/Attempt"
            },
            {
              "type": "null"
            }
          ]
        },
        "bound": {
          "oneOf": [
            {
              "$ref": "#/$defs/Bound"
            },
            {
              "type": "null"
            }
          ]
        },
        "produced": {
          "oneOf": [
            {
              "$ref": "#/$defs/Produced"
            },
            {
              "type": "null"
            }
          ]
        },
        "result": {
          "oneOf": [
            {
              "$ref": "#/$defs/Result"
            },
            {
              "type": "null"
            }
          ]
        },
        "staged": {
          "oneOf": [
            {
              "$ref": "#/$defs/Staged"
            },
            {
              "type": "null"
            }
          ]
        },
        "justifies": {
          "oneOf": [
            {
              "$ref": "#/$defs/Justifies"
            },
            {
              "type": "null"
            }
          ]
        },
        "relation": {
          "oneOf": [
            {
              "$ref": "#/$defs/RelationFact"
            },
            {
              "type": "null"
            }
          ]
        },
        "child": {
          "oneOf": [
            {
              "$ref": "#/$defs/Child"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "type": "object",
      "required": [
        "ref",
        "origin",
        "batch",
        "fact"
      ],
      "description": "Entry is one occurrence in a journal as a read returns it: its reference, origin and batch, the canonical fact bytes (base64 on the wire), and the decoded Dawn fact when the predicate is one of dawn-facts-v2."
    },
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    },
    "Justifies": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "assertion_id": {
          "type": "string"
        },
        "group": {
          "type": "string"
        },
        "premise": {
          "$ref": "#/$defs/EntryRef"
        },
        "method": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "assertion_id",
        "group",
        "premise",
        "method"
      ],
      "description": "Justifies is one premise that jointly justifies an assertion: the assertion id, the group joining its premises, the premise occurrence and the method."
    },
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    },
    "Produced": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "application": {
          "$ref": "#/$defs/EntryRef"
        },
        "role": {
          "type": "string"
        },
        "produced": {
          "$ref": "#/$defs/EntryRef"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "application",
        "role",
        "produced"
      ],
      "description": "Produced is one output occurrence of the application named by application."
    },
    "Record": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "profile": {
          "type": "string"
        },
        "hash": {
          "type": "string"
        },
        "metadata": {
          "additionalProperties": {
            "type": "string"
          },
          "type": "object"
        },
        "publisher": {
          "type": "string"
        },
        "request_id": {
          "type": "string"
        },
        "request_digest": {
          "type": "string"
        },
        "accepted_at": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "profile",
        "hash",
        "metadata",
        "publisher",
        "request_id",
        "request_digest",
        "accepted_at"
      ],
      "description": "Record is one admitted record occurrence: the fact Dawn appended to an individual record's leaf journal under dawn-facts-v2, with the provenance Dawn persists because Journal supplies none."
    },
    "RelationFact": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "assertion_id": {
          "type": "string"
        },
        "kind": {
          "type": "string"
        },
        "target": {
          "$ref": "#/$defs/EntryRef"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "assertion_id",
        "kind",
        "target"
      ],
      "description": "RelationFact is one relation of an assertion to another occurrence: supersedes, challenges or withdraws."
    },
    "Result": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "application": {
          "$ref": "#/$defs/EntryRef"
        },
        "outcome": {
          "type": "string"
        },
        "manifest": {
          "type": "string"
        },
        "resolution": {
          "type": "string"
        },
        "attestation": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "application",
        "outcome",
        "manifest",
        "resolution",
        "attestation"
      ],
      "description": "Result is the seal fact of a terminal application: its outcome, the retained manifest, resolution and seal envelope by hash."
    },
    "Space": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "path": {
          "$ref": "#/$defs/Path"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "path"
      ],
      "description": "Space is a space's identity together with its Dawn path: the labels below the world, so a grant by path applies to it."
    },
    "Staged": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "application": {
          "$ref": "#/$defs/EntryRef"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "application"
      ],
      "description": "Staged is the first fact of an artifact space an application creates, before its content fact, naming the application."
    }
  },
  "properties": {
    "space": {
      "$ref": "#/$defs/Space"
    },
    "through": {
      "type": "integer"
    },
    "entries": {
      "items": {
        "$ref": "#/$defs/Entry"
      },
      "type": "array"
    },
    "scanned_through": {
      "type": "integer"
    },
    "next_after": {
      "oneOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ]
    }
  },
  "type": "object",
  "required": [
    "space",
    "through",
    "entries",
    "scanned_through"
  ],
  "title": "EntriesPage",
  "description": "EntriesPage is one page of a journal's fixed prefix (after, through]."
}

schema/Error.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "error": {
      "type": "string"
    },
    "message": {
      "type": "string"
    },
    "details": {
      "type": "object"
    }
  },
  "type": "object",
  "required": [
    "error",
    "message"
  ],
  "title": "Error",
  "description": "Error is a refusal, with the machine-readable facts the surface promises."
}

schema/Event.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    },
    "Space": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "path": {
          "$ref": "#/$defs/Path"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "path"
      ],
      "description": "Space is a space's identity together with its Dawn path: the labels below the world, so a grant by path applies to it."
    }
  },
  "properties": {
    "space": {
      "$ref": "#/$defs/Space"
    },
    "cutoff": {
      "type": "integer"
    }
  },
  "type": "object",
  "required": [
    "space",
    "cutoff"
  ],
  "title": "Event",
  "description": "Event is one journal's advance: the space, with its path at delivery, and the committed cutoff it is now at."
}

schema/Executable.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "service_binary": {
      "type": "string"
    },
    "revision": {
      "type": "string"
    },
    "configuration": {
      "type": "string"
    }
  },
  "type": "object",
  "required": [
    "service_binary",
    "revision",
    "configuration"
  ],
  "title": "Executable",
  "description": "Executable is what the service runs a release with, filled at bootstrap and part of the release's identity: the running service binary, its revision, and the canonical configuration the tool was prepared under."
}

schema/ExplainRequest.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    }
  },
  "properties": {
    "view": {
      "$ref": "#/$defs/EntryRef"
    },
    "assertion": {
      "type": "string"
    }
  },
  "type": "object",
  "required": [
    "view",
    "assertion"
  ],
  "title": "ExplainRequest",
  "description": "ExplainRequest asks where an admitted assertion selected by a view comes from."
}

schema/ExplainResult.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    }
  },
  "properties": {
    "view": {
      "$ref": "#/$defs/EntryRef"
    },
    "assertion": {
      "type": "string"
    },
    "record": true,
    "defined_by": {
      "$ref": "#/$defs/EntryRef"
    },
    "adopted_by": {
      "oneOf": [
        {
          "$ref": "#/$defs/EntryRef"
        },
        {
          "type": "null"
        }
      ]
    },
    "disagreeing": {
      "items": {
        "$ref": "#/$defs/EntryRef"
      },
      "type": "array"
    }
  },
  "type": "object",
  "required": [
    "view",
    "assertion",
    "record",
    "defined_by",
    "disagreeing"
  ],
  "title": "ExplainResult",
  "description": "ExplainResult is the assertion's projected record, the declaration occurrence that defined it, the selection that adopted it, and the selected occurrences that disagree."
}

schema/Export.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    },
    "Space": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "path": {
          "$ref": "#/$defs/Path"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "path"
      ],
      "description": "Space is a space's identity together with its Dawn path: the labels below the world, so a grant by path applies to it."
    }
  },
  "properties": {
    "scope": {
      "$ref": "#/$defs/Space"
    },
    "manifest": {
      "type": "string"
    },
    "chunks": {
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "spaces": {
      "type": "integer"
    },
    "entries": {
      "type": "integer"
    },
    "complete": {
      "type": "boolean"
    },
    "incomplete": {
      "items": {
        "$ref": "#/$defs/Space"
      },
      "type": "array"
    },
    "next_cursor": {
      "oneOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    }
  },
  "type": "object",
  "required": [
    "scope",
    "manifest",
    "chunks",
    "spaces",
    "entries",
    "complete",
    "incomplete"
  ],
  "title": "Export",
  "description": "Export is a complete traversal of a selected subtree: every selected space's own journal prefix and child observation, retained in Bytes as one or more manifest chunks and cited by digest."
}

schema/Gap.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    },
    "Space": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "path": {
          "$ref": "#/$defs/Path"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "path"
      ],
      "description": "Space is a space's identity together with its Dawn path: the labels below the world, so a grant by path applies to it."
    }
  },
  "properties": {
    "space": {
      "$ref": "#/$defs/Space"
    }
  },
  "type": "object",
  "required": [
    "space"
  ],
  "title": "Gap",
  "description": "Gap reports a journal that advanced while the subscription's pending table was full, so the cutoff it reached was not kept."
}

schema/Health.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Build": {
      "properties": {
        "revision": {
          "type": "string"
        },
        "dirty": {
          "type": "boolean"
        },
        "go": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "revision",
        "dirty",
        "go"
      ],
      "description": "Build identifies the binary."
    },
    "Check": {
      "properties": {
        "name": {
          "type": "string"
        },
        "status": {
          "type": "string",
          "description": "ok | failing"
        },
        "detail": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "name",
        "status",
        "detail"
      ],
      "description": "Check is one dependency the service needs in order to serve its contract: for Dawn, the journal and bytes it consumes."
    },
    "Identity": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "world_space_id": {
          "type": "string"
        },
        "journal_instance_id": {
          "type": "string"
        },
        "world": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "world_space_id",
        "journal_instance_id"
      ],
      "description": "Identity is the service-specific identity member: the Journal root the world lives in, the world's own space, the Journal instance and the world's name, the space its grants are placed in."
    }
  },
  "properties": {
    "status": {
      "type": "string"
    },
    "service": {
      "type": "string"
    },
    "contract": {
      "type": "string"
    },
    "build": {
      "$ref": "#/$defs/Build"
    },
    "time": {
      "type": "string"
    },
    "checks": {
      "items": {
        "$ref": "#/$defs/Check"
      },
      "type": "array"
    },
    "identity": {
      "oneOf": [
        {
          "$ref": "#/$defs/Identity"
        },
        {
          "type": "null"
        }
      ]
    }
  },
  "type": "object",
  "required": [
    "status",
    "service",
    "contract",
    "build",
    "time",
    "checks"
  ],
  "title": "Health",
  "description": "Health is the envelope of GET /livez and GET /healthz."
}

schema/Justification.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    }
  },
  "properties": {
    "group": {
      "type": "string"
    },
    "premises": {
      "items": {
        "$ref": "#/$defs/EntryRef"
      },
      "type": "array"
    },
    "method": {
      "type": "string"
    }
  },
  "type": "object",
  "required": [
    "group",
    "premises",
    "method"
  ],
  "title": "Justification",
  "description": "Justification joins a group of premises that jointly justify a declaration: each premise becomes one justifies fact, and the group id joins them."
}

schema/OutputManifest.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Artifact": {
      "properties": {
        "bytes": {
          "type": "string"
        },
        "type": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "bytes",
        "type"
      ],
      "description": "Artifact is exact retained content with a selected interpretation: the hash of the bytes and the hash of the interpretation descriptor the bytes are read under (order 0002 D4)."
    },
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    },
    "OutputEntry": {
      "properties": {
        "role": {
          "type": "string"
        },
        "ordinal": {
          "type": "integer"
        },
        "artifact": {
          "$ref": "#/$defs/Artifact"
        },
        "entry": {
          "$ref": "#/$defs/EntryRef"
        }
      },
      "type": "object",
      "required": [
        "role",
        "ordinal",
        "artifact",
        "entry"
      ],
      "description": "OutputEntry is one output of a completed application: its role, ordinal within that role, the retained artifact and its occurrence."
    }
  },
  "properties": {
    "application": {
      "$ref": "#/$defs/EntryRef"
    },
    "outputs": {
      "items": {
        "$ref": "#/$defs/OutputEntry"
      },
      "type": "array"
    },
    "counts": true,
    "coverage": true
  },
  "type": "object",
  "required": [
    "application",
    "outputs",
    "counts",
    "coverage"
  ],
  "title": "OutputManifest",
  "description": "OutputManifest is the retained manifest of a completed application's outputs: one entry per output occurrence in role order, the counts and the coverage the tool reported."
}

schema/ProvisionWorkerRequest.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    },
    "Permission": {
      "properties": {
        "kind": {
          "type": "string"
        },
        "path": {
          "$ref": "#/$defs/Path"
        }
      },
      "type": "object",
      "required": [
        "kind",
        "path"
      ],
      "description": "Permission is one grant a provisioning asks for: a kind on a subtree."
    }
  },
  "properties": {
    "operation_id": {
      "type": "string"
    },
    "project": {
      "type": "string"
    },
    "worker": {
      "type": "string"
    },
    "principal": {
      "type": "string"
    },
    "permissions": {
      "items": {
        "$ref": "#/$defs/Permission"
      },
      "type": "array"
    },
    "valid_until": {
      "type": "string"
    }
  },
  "type": "object",
  "required": [
    "operation_id",
    "project",
    "worker",
    "principal",
    "permissions",
    "valid_until"
  ],
  "title": "ProvisionWorkerRequest",
  "description": "ProvisionWorkerRequest creates a worker space under its project and issues its grants to a public key the provisioner generated into the workspace."
}

schema/ProvisionWorkerResult.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    },
    "Grant": {
      "properties": {
        "principal": {
          "type": "string"
        },
        "kind": {
          "type": "string"
        },
        "path": {
          "$ref": "#/$defs/Path"
        },
        "valid_until": {
          "type": "string"
        },
        "issuer": {
          "type": "string"
        },
        "signature": {
          "type": "string",
          "description": "base64 of the 64 Ed25519 signature bytes over the fact"
        }
      },
      "type": "object",
      "required": [
        "principal",
        "kind",
        "path",
        "valid_until",
        "issuer",
        "signature"
      ],
      "description": "Grant is what a principal carries to prove it may act: a kind on a subtree until an instant, issued by another principal (the root or a delegate)."
    },
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    },
    "Record": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "profile": {
          "type": "string"
        },
        "hash": {
          "type": "string"
        },
        "metadata": {
          "additionalProperties": {
            "type": "string"
          },
          "type": "object"
        },
        "publisher": {
          "type": "string"
        },
        "request_id": {
          "type": "string"
        },
        "request_digest": {
          "type": "string"
        },
        "accepted_at": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "profile",
        "hash",
        "metadata",
        "publisher",
        "request_id",
        "request_digest",
        "accepted_at"
      ],
      "description": "Record is one admitted record occurrence: the fact Dawn appended to an individual record's leaf journal under dawn-facts-v2, with the provenance Dawn persists because Journal supplies none."
    },
    "Space": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "path": {
          "$ref": "#/$defs/Path"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "path"
      ],
      "description": "Space is a space's identity together with its Dawn path: the labels below the world, so a grant by path applies to it."
    },
    "Workspace": {
      "properties": {
        "endpoint": {
          "type": "string"
        },
        "audience": {
          "type": "string"
        },
        "principal": {
          "type": "string"
        },
        "project": {
          "type": "string"
        },
        "worker": {
          "type": "string"
        },
        "path": {
          "$ref": "#/$defs/Path"
        }
      },
      "type": "object",
      "required": [
        "endpoint",
        "audience",
        "principal",
        "project",
        "worker",
        "path"
      ],
      "description": "Workspace is what a prepared directory needs to know: the endpoint, the audience its proofs name, its principal and its path; never a backend."
    }
  },
  "properties": {
    "space": {
      "$ref": "#/$defs/Space"
    },
    "state": {
      "$ref": "#/$defs/Record"
    },
    "grants": {
      "items": {
        "$ref": "#/$defs/Grant"
      },
      "type": "array"
    },
    "workspace": {
      "$ref": "#/$defs/Workspace"
    },
    "replayed": {
      "type": "boolean"
    }
  },
  "type": "object",
  "required": [
    "space",
    "state",
    "grants",
    "workspace",
    "replayed"
  ],
  "title": "ProvisionWorkerResult",
  "description": "ProvisionWorkerResult is the worker's space, its initial state record, the grants and the workspace material."
}

schema/PublishRequest.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    }
  },
  "properties": {
    "operation_id": {
      "type": "string"
    },
    "path": {
      "$ref": "#/$defs/Path"
    },
    "expected_cutoff": {
      "oneOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ]
    },
    "profile": {
      "type": "string"
    },
    "record": true,
    "metadata": {
      "additionalProperties": {
        "type": "string"
      },
      "type": "object"
    }
  },
  "type": "object",
  "required": [
    "operation_id",
    "path",
    "profile",
    "record"
  ],
  "title": "PublishRequest",
  "description": "PublishRequest appends a record to the individual record's leaf journal at path, creating the leaf under its organizer when absent."
}

schema/PublishResult.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    },
    "Record": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "profile": {
          "type": "string"
        },
        "hash": {
          "type": "string"
        },
        "metadata": {
          "additionalProperties": {
            "type": "string"
          },
          "type": "object"
        },
        "publisher": {
          "type": "string"
        },
        "request_id": {
          "type": "string"
        },
        "request_digest": {
          "type": "string"
        },
        "accepted_at": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "profile",
        "hash",
        "metadata",
        "publisher",
        "request_id",
        "request_digest",
        "accepted_at"
      ],
      "description": "Record is one admitted record occurrence: the fact Dawn appended to an individual record's leaf journal under dawn-facts-v2, with the provenance Dawn persists because Journal supplies none."
    }
  },
  "properties": {
    "record": {
      "$ref": "#/$defs/Record"
    },
    "space_created": {
      "type": "boolean"
    },
    "replayed": {
      "type": "boolean"
    }
  },
  "type": "object",
  "required": [
    "record",
    "space_created",
    "replayed"
  ],
  "title": "PublishResult",
  "description": "PublishResult is the accepted or recovered outcome: the record occurrence, whether this operation created the leaf journal, and whether the result was recovered from an earlier admission of the same request."
}

schema/QueryRequest.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    }
  },
  "properties": {
    "view": {
      "$ref": "#/$defs/EntryRef"
    },
    "filters": true,
    "cursor": {
      "oneOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    },
    "limit": {
      "type": "integer"
    }
  },
  "type": "object",
  "required": [
    "view",
    "filters"
  ],
  "title": "QueryRequest",
  "description": "QueryRequest asks a view occurrence for records."
}

schema/QueryResult.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    }
  },
  "properties": {
    "view": {
      "$ref": "#/$defs/EntryRef"
    },
    "outcome": {
      "type": "string"
    },
    "records": {
      "items": true,
      "type": "array"
    },
    "coverage": true,
    "limits": {
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "next_cursor": {
      "oneOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    }
  },
  "type": "object",
  "required": [
    "view",
    "outcome",
    "records",
    "coverage",
    "limits"
  ],
  "title": "QueryResult",
  "description": "QueryResult carries records with the view, coverage and limits it holds for."
}

schema/Record.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    }
  },
  "properties": {
    "entry": {
      "$ref": "#/$defs/EntryRef"
    },
    "profile": {
      "type": "string"
    },
    "hash": {
      "type": "string"
    },
    "metadata": {
      "additionalProperties": {
        "type": "string"
      },
      "type": "object"
    },
    "publisher": {
      "type": "string"
    },
    "request_id": {
      "type": "string"
    },
    "request_digest": {
      "type": "string"
    },
    "accepted_at": {
      "type": "string"
    }
  },
  "type": "object",
  "required": [
    "entry",
    "profile",
    "hash",
    "metadata",
    "publisher",
    "request_id",
    "request_digest",
    "accepted_at"
  ],
  "title": "Record",
  "description": "Record is one admitted record occurrence: the fact Dawn appended to an individual record's leaf journal under dawn-facts-v2, with the provenance Dawn persists because Journal supplies none."
}

schema/RecordRead.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Artifact": {
      "properties": {
        "bytes": {
          "type": "string"
        },
        "type": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "bytes",
        "type"
      ],
      "description": "Artifact is exact retained content with a selected interpretation: the hash of the bytes and the hash of the interpretation descriptor the bytes are read under (order 0002 D4)."
    },
    "Attempt": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "release": {
          "$ref": "#/$defs/EntryRef"
        },
        "request": {
          "type": "string"
        },
        "publisher": {
          "type": "string"
        },
        "request_id": {
          "type": "string"
        },
        "request_digest": {
          "type": "string"
        },
        "accepted_at": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "release",
        "request",
        "publisher",
        "request_id",
        "request_digest",
        "accepted_at"
      ],
      "description": "Attempt is one admitted application's attempt fact: the release occurrence that ran, the retained normalized request by hash, and Dawn's admission provenance for the attempt."
    },
    "Batch": {
      "properties": {
        "first": {
          "type": "integer"
        },
        "last": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "first",
        "last"
      ],
      "description": "Batch is the committed batch an entry belongs to."
    },
    "Bound": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "application": {
          "$ref": "#/$defs/EntryRef"
        },
        "role": {
          "type": "string"
        },
        "bound": {
          "$ref": "#/$defs/EntryRef"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "application",
        "role",
        "bound"
      ],
      "description": "Bound is one input role of the application named by application, bound to one occurrence."
    },
    "Child": {
      "properties": {
        "key": {
          "type": "string"
        },
        "space": {
          "$ref": "#/$defs/Space"
        },
        "created_at": {
          "$ref": "#/$defs/EntryRef"
        }
      },
      "type": "object",
      "required": [
        "key",
        "space",
        "created_at"
      ],
      "description": "Child is one child of a space at the parent's selected cutoff, with the creation entry that recorded it: Journal's own child observation."
    },
    "Declaration": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "assertion_id": {
          "type": "string"
        },
        "envelope": {
          "type": "string"
        },
        "artifact": {
          "$ref": "#/$defs/Artifact"
        },
        "subject": {
          "type": "string"
        },
        "publisher": {
          "type": "string"
        },
        "application": {
          "oneOf": [
            {
              "$ref": "#/$defs/EntryRef"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "type": "object",
      "required": [
        "entry",
        "assertion_id",
        "envelope",
        "artifact",
        "publisher"
      ],
      "description": "Declaration is one admitted declaration occurrence: the fact in an artifact's declarations journal."
    },
    "Entry": {
      "properties": {
        "ref": {
          "$ref": "#/$defs/EntryRef"
        },
        "origin": {
          "type": "string"
        },
        "batch": {
          "$ref": "#/$defs/Batch"
        },
        "fact": {
          "type": "string",
          "contentEncoding": "base64"
        },
        "content": {
          "oneOf": [
            {
              "$ref": "#/$defs/Artifact"
            },
            {
              "type": "null"
            }
          ]
        },
        "declaration": {
          "oneOf": [
            {
              "$ref": "#/$defs/Declaration"
            },
            {
              "type": "null"
            }
          ]
        },
        "record": {
          "oneOf": [
            {
              "$ref": "#/$defs/Record"
            },
            {
              "type": "null"
            }
          ]
        },
        "attempt": {
          "oneOf": [
            {
              "$ref": "#/$defs/Attempt"
            },
            {
              "type": "null"
            }
          ]
        },
        "bound": {
          "oneOf": [
            {
              "$ref": "#/$defs/Bound"
            },
            {
              "type": "null"
            }
          ]
        },
        "produced": {
          "oneOf": [
            {
              "$ref": "#/$defs/Produced"
            },
            {
              "type": "null"
            }
          ]
        },
        "result": {
          "oneOf": [
            {
              "$ref": "#/$defs/Result"
            },
            {
              "type": "null"
            }
          ]
        },
        "staged": {
          "oneOf": [
            {
              "$ref": "#/$defs/Staged"
            },
            {
              "type": "null"
            }
          ]
        },
        "justifies": {
          "oneOf": [
            {
              "$ref": "#/$defs/Justifies"
            },
            {
              "type": "null"
            }
          ]
        },
        "relation": {
          "oneOf": [
            {
              "$ref": "#/$defs/RelationFact"
            },
            {
              "type": "null"
            }
          ]
        },
        "child": {
          "oneOf": [
            {
              "$ref": "#/$defs/Child"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "type": "object",
      "required": [
        "ref",
        "origin",
        "batch",
        "fact"
      ],
      "description": "Entry is one occurrence in a journal as a read returns it: its reference, origin and batch, the canonical fact bytes (base64 on the wire), and the decoded Dawn fact when the predicate is one of dawn-facts-v2."
    },
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    },
    "Justifies": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "assertion_id": {
          "type": "string"
        },
        "group": {
          "type": "string"
        },
        "premise": {
          "$ref": "#/$defs/EntryRef"
        },
        "method": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "assertion_id",
        "group",
        "premise",
        "method"
      ],
      "description": "Justifies is one premise that jointly justifies an assertion: the assertion id, the group joining its premises, the premise occurrence and the method."
    },
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    },
    "Produced": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "application": {
          "$ref": "#/$defs/EntryRef"
        },
        "role": {
          "type": "string"
        },
        "produced": {
          "$ref": "#/$defs/EntryRef"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "application",
        "role",
        "produced"
      ],
      "description": "Produced is one output occurrence of the application named by application."
    },
    "Record": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "profile": {
          "type": "string"
        },
        "hash": {
          "type": "string"
        },
        "metadata": {
          "additionalProperties": {
            "type": "string"
          },
          "type": "object"
        },
        "publisher": {
          "type": "string"
        },
        "request_id": {
          "type": "string"
        },
        "request_digest": {
          "type": "string"
        },
        "accepted_at": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "profile",
        "hash",
        "metadata",
        "publisher",
        "request_id",
        "request_digest",
        "accepted_at"
      ],
      "description": "Record is one admitted record occurrence: the fact Dawn appended to an individual record's leaf journal under dawn-facts-v2, with the provenance Dawn persists because Journal supplies none."
    },
    "RelationFact": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "assertion_id": {
          "type": "string"
        },
        "kind": {
          "type": "string"
        },
        "target": {
          "$ref": "#/$defs/EntryRef"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "assertion_id",
        "kind",
        "target"
      ],
      "description": "RelationFact is one relation of an assertion to another occurrence: supersedes, challenges or withdraws."
    },
    "Result": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "application": {
          "$ref": "#/$defs/EntryRef"
        },
        "outcome": {
          "type": "string"
        },
        "manifest": {
          "type": "string"
        },
        "resolution": {
          "type": "string"
        },
        "attestation": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "application",
        "outcome",
        "manifest",
        "resolution",
        "attestation"
      ],
      "description": "Result is the seal fact of a terminal application: its outcome, the retained manifest, resolution and seal envelope by hash."
    },
    "Space": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "path": {
          "$ref": "#/$defs/Path"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "path"
      ],
      "description": "Space is a space's identity together with its Dawn path: the labels below the world, so a grant by path applies to it."
    },
    "Staged": {
      "properties": {
        "entry": {
          "$ref": "#/$defs/EntryRef"
        },
        "application": {
          "$ref": "#/$defs/EntryRef"
        }
      },
      "type": "object",
      "required": [
        "entry",
        "application"
      ],
      "description": "Staged is the first fact of an artifact space an application creates, before its content fact, naming the application."
    }
  },
  "properties": {
    "space": {
      "$ref": "#/$defs/Space"
    },
    "entry": {
      "$ref": "#/$defs/Entry"
    }
  },
  "type": "object",
  "required": [
    "space",
    "entry"
  ],
  "title": "RecordRead",
  "description": "RecordRead is one exact occurrence, read by its reference at a valid covering cutoff, with the space it lies in resolved to its Dawn path."
}

schema/Refusal.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "request": true,
    "reason": {
      "type": "string"
    },
    "publisher": {
      "type": "string"
    },
    "refused_at": {
      "type": "string"
    }
  },
  "type": "object",
  "required": [
    "request",
    "reason",
    "publisher",
    "refused_at"
  ],
  "title": "Refusal",
  "description": "RefusalRecord is the retained payload of a dawn/refusal/1 record: an authenticated, well-formed request that could not be applied, with the reason, written under the application leaf in place of an attempt."
}

schema/Relation.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    }
  },
  "properties": {
    "kind": {
      "type": "string"
    },
    "target": {
      "$ref": "#/$defs/EntryRef"
    }
  },
  "type": "object",
  "required": [
    "kind",
    "target"
  ],
  "title": "Relation",
  "description": "Relation names a declaration's relation to another occurrence: supersedes, challenges or withdraws."
}

schema/ResolveResult.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    },
    "Space": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "path": {
          "$ref": "#/$defs/Path"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "path"
      ],
      "description": "Space is a space's identity together with its Dawn path: the labels below the world, so a grant by path applies to it."
    }
  },
  "properties": {
    "space": {
      "oneOf": [
        {
          "$ref": "#/$defs/Space"
        },
        {
          "type": "null"
        }
      ]
    }
  },
  "type": "object",
  "required": [
    "space"
  ],
  "title": "ResolveResult",
  "description": "ResolveResult is the space at a path, or null when the path is unoccupied."
}

schema/ResultSeal.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "EntryRef": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "position": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "position"
      ],
      "description": "EntryRef is the occurrence identity of one entry: a position in one journal."
    }
  },
  "properties": {
    "application": {
      "$ref": "#/$defs/EntryRef"
    },
    "release": {
      "$ref": "#/$defs/EntryRef"
    },
    "bound": {
      "items": {
        "$ref": "#/$defs/EntryRef"
      },
      "type": "array"
    },
    "produced": {
      "items": {
        "$ref": "#/$defs/EntryRef"
      },
      "type": "array"
    },
    "outcome": {
      "type": "string"
    },
    "environment": {
      "type": "string"
    },
    "manifest": {
      "type": "string"
    },
    "resolution": {
      "type": "string"
    },
    "signed_at": {
      "type": "string"
    },
    "signature": {
      "type": "string"
    }
  },
  "type": "object",
  "required": [
    "application",
    "release",
    "bound",
    "produced",
    "outcome",
    "environment",
    "manifest",
    "resolution",
    "signed_at",
    "signature"
  ],
  "title": "ResultSeal",
  "description": "ResultSeal is the retained, signed envelope of a terminal application: the application and release, every bound and produced occurrence, the outcome, the retained environment, manifest and resolution, and the service root's signature over the canonical seal with the signature empty."
}

schema/RetainResult.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Artifact": {
      "properties": {
        "bytes": {
          "type": "string"
        },
        "type": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "bytes",
        "type"
      ],
      "description": "Artifact is exact retained content with a selected interpretation: the hash of the bytes and the hash of the interpretation descriptor the bytes are read under (order 0002 D4)."
    }
  },
  "properties": {
    "artifact": {
      "$ref": "#/$defs/Artifact"
    },
    "size": {
      "type": "integer"
    }
  },
  "type": "object",
  "required": [
    "artifact",
    "size"
  ],
  "title": "RetainResult",
  "description": "RetainResult names bytes that were retained and verified."
}

schema/RetireWorkerRequest.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "operation_id": {
      "type": "string"
    },
    "project": {
      "type": "string"
    },
    "worker": {
      "type": "string"
    }
  },
  "type": "object",
  "required": [
    "operation_id",
    "project",
    "worker"
  ],
  "title": "RetireWorkerRequest",
  "description": "RetireWorkerRequest records that a worker's window is closed."
}

schema/Role.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "name": {
      "type": "string"
    },
    "doc": {
      "type": "string"
    },
    "required": {
      "type": "boolean"
    },
    "dynamic": {
      "type": "boolean"
    },
    "accepts": {
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "yields": {
      "type": "string"
    }
  },
  "type": "object",
  "required": [
    "name",
    "doc"
  ],
  "title": "Role",
  "description": "Role is one declared input or output of a tool."
}

schema/Snapshot.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Manifest": {
      "properties": {
        "scope": {
          "$ref": "#/$defs/Space"
        },
        "max_depth": {
          "oneOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ]
        },
        "spaces": {
          "items": {
            "$ref": "#/$defs/ManifestSpace"
          },
          "type": "array"
        }
      },
      "type": "object",
      "required": [
        "scope",
        "max_depth",
        "spaces"
      ],
      "description": "Manifest is an explicit selection of journal prefixes: the scope and every selected descendant with its cutoff, in depth-first preorder by child creation."
    },
    "ManifestSpace": {
      "properties": {
        "space": {
          "$ref": "#/$defs/Space"
        },
        "through": {
          "type": "integer"
        }
      },
      "type": "object",
      "required": [
        "space",
        "through"
      ],
      "description": "ManifestSpace is one selected space and the cutoff its entries were selected through."
    },
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    },
    "Space": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "path": {
          "$ref": "#/$defs/Path"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "path"
      ],
      "description": "Space is a space's identity together with its Dawn path: the labels below the world, so a grant by path applies to it."
    }
  },
  "properties": {
    "manifest": {
      "$ref": "#/$defs/Manifest"
    },
    "digest": {
      "type": "string"
    }
  },
  "type": "object",
  "required": [
    "manifest",
    "digest"
  ],
  "title": "Snapshot",
  "description": "Snapshot is a captured manifest, retained in Bytes as canonical JSON and cited by that digest."
}

schema/SpaceResult.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    },
    "Space": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "path": {
          "$ref": "#/$defs/Path"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "path"
      ],
      "description": "Space is a space's identity together with its Dawn path: the labels below the world, so a grant by path applies to it."
    }
  },
  "properties": {
    "space": {
      "$ref": "#/$defs/Space"
    },
    "replayed": {
      "type": "boolean"
    }
  },
  "type": "object",
  "required": [
    "space",
    "replayed"
  ],
  "title": "SpaceResult",
  "description": "SpaceResult is the outcome of creating structure without a record."
}

schema/SubscribeRequest.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    }
  },
  "properties": {
    "scope": {
      "$ref": "#/$defs/Path"
    }
  },
  "type": "object",
  "required": [
    "scope"
  ],
  "title": "SubscribeRequest",
  "description": "SubscribeRequest opens a subscription over a scope."
}

schema/SubscribeResult.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Path": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "Path is a location in the world: labels from a root organizer down, relative to the world."
    },
    "Space": {
      "properties": {
        "root_id": {
          "type": "string"
        },
        "space_id": {
          "type": "string"
        },
        "path": {
          "$ref": "#/$defs/Path"
        }
      },
      "type": "object",
      "required": [
        "root_id",
        "space_id",
        "path"
      ],
      "description": "Space is a space's identity together with its Dawn path: the labels below the world, so a grant by path applies to it."
    }
  },
  "properties": {
    "subscription": {
      "type": "string"
    },
    "scope": {
      "$ref": "#/$defs/Space"
    },
    "expires_at": {
      "type": "string",
      "description": "ExpiresAt is when the service stops delivering: the earlier of the\ngrant's validity end and the configured maximum. Renewal is a fresh\nsubscribe with a fresh proof, because events carry no proof of their own."
    }
  },
  "type": "object",
  "required": [
    "subscription",
    "scope",
    "expires_at"
  ],
  "title": "SubscribeResult",
  "description": "SubscribeResult reports the open subscription."
}

schema/SubscriptionClosed.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "reason": {
      "type": "string"
    },
    "delivered": {
      "type": "integer"
    }
  },
  "type": "object",
  "required": [
    "reason",
    "delivered"
  ],
  "title": "SubscriptionClosed",
  "description": "SubscriptionClosed is the last frame of a subscription."
}

schema/ToolDescription.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$defs": {
    "Executable": {
      "properties": {
        "service_binary": {
          "type": "string"
        },
        "revision": {
          "type": "string"
        },
        "configuration": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "service_binary",
        "revision",
        "configuration"
      ],
      "description": "Executable is what the service runs a release with, filled at bootstrap and part of the release's identity: the running service binary, its revision, and the canonical configuration the tool was prepared under."
    },
    "Role": {
      "properties": {
        "name": {
          "type": "string"
        },
        "doc": {
          "type": "string"
        },
        "required": {
          "type": "boolean"
        },
        "dynamic": {
          "type": "boolean"
        },
        "accepts": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "yields": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "name",
        "doc"
      ],
      "description": "Role is one declared input or output of a tool."
    }
  },
  "properties": {
    "name": {
      "type": "string"
    },
    "version": {
      "type": "string"
    },
    "doc": {
      "type": "string"
    },
    "class": {
      "type": "string"
    },
    "inputs": {
      "items": {
        "$ref": "#/$defs/Role"
      },
      "type": "array"
    },
    "outputs": {
      "items": {
        "$ref": "#/$defs/Role"
      },
      "type": "array"
    },
    "effects": {
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "recipe_doc": {
      "type": "string"
    },
    "deterministic": {
      "type": "boolean"
    },
    "egress": {
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "executable": {
      "$ref": "#/$defs/Executable"
    }
  },
  "type": "object",
  "required": [
    "name",
    "version",
    "doc",
    "class",
    "inputs",
    "outputs",
    "effects",
    "recipe_doc",
    "deterministic",
    "egress",
    "executable"
  ],
  "title": "ToolDescription",
  "description": "ToolDescription is the retained content of a release's artifact space under the world's tools: what the tool is, what it takes and yields, whether running it twice on one valuation is expected to agree, which hosts it may reach, and how the service executes it."
}

schema/UnsubscribeResult.schema.json

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "subscription": {
      "type": "string"
    },
    "delivered": {
      "type": "integer"
    }
  },
  "type": "object",
  "required": [
    "subscription",
    "delivered"
  ],
  "title": "UnsubscribeResult",
  "description": "UnsubscribeResult reports a closed subscription."
}

OpenAPI

openapi.json (raw)

{
  "components": {
    "schemas": {
      "AcquisitionTarget": {
        "description": "AcquisitionTarget is the payload of a dawn/acquisition-target/1 record: what an intake tool is to fetch.",
        "properties": {
          "expected": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/ExpectedHash"
              },
              {
                "type": "null"
              }
            ]
          },
          "expected_source": {
            "type": "string"
          },
          "label": {
            "type": "string"
          },
          "locator": {
            "type": "string"
          },
          "type": {
            "type": "string"
          }
        },
        "required": [
          "locator",
          "type"
        ],
        "title": "AcquisitionTarget",
        "type": "object"
      },
      "ApplicationRequest": {
        "description": "ApplicationRequest is the retained normalized request: the tool as resolved, the release occurrence, the bound inputs and the canonicalized recipe.",
        "properties": {
          "inputs": {
            "additionalProperties": {
              "$ref": "#/components/schemas/EntryRef"
            },
            "type": "object"
          },
          "normalization": {
            "type": "string"
          },
          "recipe": true,
          "release": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "tool": {
            "type": "string"
          }
        },
        "required": [
          "tool",
          "release",
          "inputs",
          "recipe",
          "normalization"
        ],
        "title": "ApplicationRequest",
        "type": "object"
      },
      "ApplyRequest": {
        "description": "ApplyRequest asks Dawn to run a configured tool on a valuation and record the application at path, a leaf under a project's applications.",
        "properties": {
          "inputs": {
            "additionalProperties": {
              "$ref": "#/components/schemas/EntryRef"
            },
            "type": "object"
          },
          "operation_id": {
            "type": "string"
          },
          "path": {
            "$ref": "#/components/schemas/Path"
          },
          "recipe": true,
          "release": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/EntryRef"
              },
              {
                "type": "null"
              }
            ]
          },
          "tool": {
            "type": "string"
          },
          "wait": {
            "type": "boolean"
          }
        },
        "required": [
          "operation_id",
          "path",
          "tool",
          "inputs",
          "recipe"
        ],
        "title": "ApplyRequest",
        "type": "object"
      },
      "ApplyResult": {
        "description": "ApplyResult is the admitted attempt and where it stands: the attempt's occurrence A; the release occurrence that ran; the outcome; on completion the result's head occurrence and its outputs by role; on failure the reason.",
        "properties": {
          "attempt": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "outcome": {
            "type": "string"
          },
          "outputs": {
            "additionalProperties": {
              "$ref": "#/components/schemas/Artifact"
            },
            "type": "object"
          },
          "reason": {
            "type": "string"
          },
          "release": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "replayed": {
            "type": "boolean"
          },
          "result": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/EntryRef"
              },
              {
                "type": "null"
              }
            ]
          },
          "reused": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/EntryRef"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "attempt",
          "release",
          "outcome",
          "replayed"
        ],
        "title": "ApplyResult",
        "type": "object"
      },
      "Artifact": {
        "description": "Artifact is exact retained content with a selected interpretation: the hash of the bytes and the hash of the interpretation descriptor the bytes are read under (order 0002 D4).",
        "properties": {
          "bytes": {
            "type": "string"
          },
          "type": {
            "type": "string"
          }
        },
        "required": [
          "bytes",
          "type"
        ],
        "type": "object"
      },
      "ArtifactResult": {
        "description": "ArtifactResult is the artifact space, its one content occurrence and its declarations space, created or recovered.",
        "properties": {
          "content": {
            "$ref": "#/components/schemas/Content"
          },
          "declarations": {
            "$ref": "#/components/schemas/Space"
          },
          "replayed": {
            "type": "boolean"
          },
          "space": {
            "$ref": "#/components/schemas/Space"
          }
        },
        "required": [
          "space",
          "content",
          "declarations",
          "replayed"
        ],
        "title": "ArtifactResult",
        "type": "object"
      },
      "AssignRequest": {
        "description": "AssignRequest publishes an assignment: pinned input occurrences, intended outputs under the worker's space or an artifact's declarations, and the brief the worker's session starts from.",
        "properties": {
          "assignment": {
            "type": "string"
          },
          "brief": {
            "type": "string"
          },
          "campaign": {
            "type": "string"
          },
          "expected_cutoff": {
            "oneOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ]
          },
          "inputs": {
            "items": {
              "$ref": "#/components/schemas/EntryRef"
            },
            "type": "array"
          },
          "operation_id": {
            "type": "string"
          },
          "outputs": {
            "items": {
              "$ref": "#/components/schemas/Path"
            },
            "type": "array"
          },
          "worker": {
            "type": "string"
          }
        },
        "required": [
          "operation_id",
          "campaign",
          "assignment",
          "worker",
          "inputs",
          "outputs"
        ],
        "title": "AssignRequest",
        "type": "object"
      },
      "Attempt": {
        "description": "Attempt is one admitted application's attempt fact: the release occurrence that ran, the retained normalized request by hash, and Dawn's admission provenance for the attempt.",
        "properties": {
          "accepted_at": {
            "type": "string"
          },
          "entry": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "publisher": {
            "type": "string"
          },
          "release": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "request": {
            "type": "string"
          },
          "request_digest": {
            "type": "string"
          },
          "request_id": {
            "type": "string"
          }
        },
        "required": [
          "entry",
          "release",
          "request",
          "publisher",
          "request_id",
          "request_digest",
          "accepted_at"
        ],
        "type": "object"
      },
      "Batch": {
        "description": "Batch is the committed batch an entry belongs to.",
        "properties": {
          "first": {
            "type": "integer"
          },
          "last": {
            "type": "integer"
          }
        },
        "required": [
          "first",
          "last"
        ],
        "type": "object"
      },
      "BindingHTTP": {
        "description": "BindingHTTP describes the HTTP binding in the describe document.",
        "properties": {
          "prefix": {
            "type": "string"
          }
        },
        "required": [
          "prefix"
        ],
        "type": "object"
      },
      "BindingWS": {
        "description": "BindingWS describes the socket binding.",
        "properties": {
          "path": {
            "type": "string"
          },
          "subprotocol": {
            "type": "string"
          }
        },
        "required": [
          "path",
          "subprotocol"
        ],
        "type": "object"
      },
      "Bindings": {
        "description": "Bindings names the primary binding and describes each offered one.",
        "properties": {
          "http": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/BindingHTTP"
              },
              {
                "type": "null"
              }
            ]
          },
          "primary": {
            "type": "string"
          },
          "ws": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/BindingWS"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "primary"
        ],
        "type": "object"
      },
      "Bound": {
        "description": "Bound is one input role of the application named by application, bound to one occurrence.",
        "properties": {
          "application": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "bound": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "entry": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "role": {
            "type": "string"
          }
        },
        "required": [
          "entry",
          "application",
          "role",
          "bound"
        ],
        "type": "object"
      },
      "Build": {
        "description": "Build identifies the binary.",
        "properties": {
          "dirty": {
            "type": "boolean"
          },
          "go": {
            "type": "string"
          },
          "revision": {
            "type": "string"
          }
        },
        "required": [
          "revision",
          "dirty",
          "go"
        ],
        "type": "object"
      },
      "Carriage": {
        "description": "Carriage is the proof and the grants a request carries.",
        "properties": {
          "grants": {
            "items": {
              "$ref": "#/components/schemas/Grant"
            },
            "type": "array"
          },
          "proof": {
            "$ref": "#/components/schemas/Proof"
          }
        },
        "required": [
          "proof",
          "grants"
        ],
        "title": "Carriage",
        "type": "object"
      },
      "Check": {
        "description": "Check is one dependency the service needs in order to serve its contract: for Dawn, the journal and bytes it consumes.",
        "properties": {
          "detail": {
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "status": {
            "description": "ok | failing",
            "type": "string"
          }
        },
        "required": [
          "name",
          "status",
          "detail"
        ],
        "type": "object"
      },
      "Child": {
        "description": "Child is one child of a space at the parent's selected cutoff, with the creation entry that recorded it: Journal's own child observation.",
        "properties": {
          "created_at": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "key": {
            "type": "string"
          },
          "space": {
            "$ref": "#/components/schemas/Space"
          }
        },
        "required": [
          "key",
          "space",
          "created_at"
        ],
        "type": "object"
      },
      "ChildrenPage": {
        "description": "ChildrenPage is one page of a space's readable children at a fixed cutoff.",
        "properties": {
          "children": {
            "items": {
              "$ref": "#/components/schemas/Child"
            },
            "type": "array"
          },
          "next_cursor": {
            "oneOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ]
          },
          "space": {
            "$ref": "#/components/schemas/Space"
          },
          "through": {
            "type": "integer"
          }
        },
        "required": [
          "space",
          "through",
          "children"
        ],
        "title": "ChildrenPage",
        "type": "object"
      },
      "ComposeRequest": {
        "description": "ComposeRequest composes a view from exact occurrence selections and publishes it as a record under views/.",
        "properties": {
          "expected_cutoff": {
            "oneOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ]
          },
          "interpretation_profile": {
            "type": "string"
          },
          "metadata": {
            "additionalProperties": {
              "type": "string"
            },
            "type": "object"
          },
          "operation_id": {
            "type": "string"
          },
          "path": {
            "$ref": "#/components/schemas/Path"
          },
          "rules": true,
          "selections": {
            "items": {
              "$ref": "#/components/schemas/EntryRef"
            },
            "type": "array"
          }
        },
        "required": [
          "operation_id",
          "path",
          "selections",
          "rules",
          "interpretation_profile"
        ],
        "title": "ComposeRequest",
        "type": "object"
      },
      "Content": {
        "description": "Content is the one content occurrence of an artifact space.",
        "properties": {
          "artifact": {
            "$ref": "#/components/schemas/Artifact"
          },
          "entry": {
            "$ref": "#/components/schemas/EntryRef"
          }
        },
        "required": [
          "entry",
          "artifact"
        ],
        "type": "object"
      },
      "CreateArtifactRequest": {
        "description": "CreateArtifactRequest creates an artifact space at projects/\u003cproject\u003e/artifacts/\u003clabel\u003e with exactly one content fact naming already retained content, and its declarations space.",
        "properties": {
          "artifact": {
            "$ref": "#/components/schemas/Artifact"
          },
          "operation_id": {
            "type": "string"
          },
          "path": {
            "$ref": "#/components/schemas/Path"
          }
        },
        "required": [
          "operation_id",
          "path",
          "artifact"
        ],
        "title": "CreateArtifactRequest",
        "type": "object"
      },
      "CreateCampaignRequest": {
        "description": "CreateCampaignRequest creates a campaign space over a project.",
        "properties": {
          "label": {
            "type": "string"
          },
          "operation_id": {
            "type": "string"
          },
          "project": {
            "type": "string"
          }
        },
        "required": [
          "operation_id",
          "label",
          "project"
        ],
        "title": "CreateCampaignRequest",
        "type": "object"
      },
      "CreateProjectRequest": {
        "description": "CreateProjectRequest creates a project space with its organizing spaces.",
        "properties": {
          "label": {
            "type": "string"
          },
          "operation_id": {
            "type": "string"
          }
        },
        "required": [
          "operation_id",
          "label"
        ],
        "title": "CreateProjectRequest",
        "type": "object"
      },
      "Declaration": {
        "description": "Declaration is one admitted declaration occurrence: the fact in an artifact's declarations journal.",
        "properties": {
          "application": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/EntryRef"
              },
              {
                "type": "null"
              }
            ]
          },
          "artifact": {
            "$ref": "#/components/schemas/Artifact"
          },
          "assertion_id": {
            "type": "string"
          },
          "entry": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "envelope": {
            "type": "string"
          },
          "publisher": {
            "type": "string"
          },
          "subject": {
            "type": "string"
          }
        },
        "required": [
          "entry",
          "assertion_id",
          "envelope",
          "artifact",
          "publisher"
        ],
        "title": "Declaration",
        "type": "object"
      },
      "DeclarationAdmission": {
        "description": "DeclarationAdmission records the world, root, exact destination space and its path at admission, the retained frame manifest, Dawn's admission policy, the accepted instant, the worker's request proof and grants, and the root's signature.",
        "properties": {
          "accepted_at": {
            "type": "string"
          },
          "auth": {
            "$ref": "#/components/schemas/Carriage"
          },
          "frame": {
            "type": "string"
          },
          "path": {
            "$ref": "#/components/schemas/Path"
          },
          "policy": {
            "type": "string"
          },
          "request_body": {
            "contentEncoding": "base64",
            "type": "string"
          },
          "root": {
            "type": "string"
          },
          "signature": {
            "type": "string"
          },
          "space": {
            "$ref": "#/components/schemas/SpaceRef"
          },
          "world": {
            "type": "string"
          }
        },
        "required": [
          "world",
          "root",
          "space",
          "path",
          "frame",
          "policy",
          "accepted_at",
          "auth",
          "request_body",
          "signature"
        ],
        "type": "object"
      },
      "DeclarationFrame": {
        "description": "DeclarationFrame is what the act was made against, retained in Bytes as canonical JSON and named by digest in the admission: the artifact's content reference, the cited evidence occurrences, the grants and proof relied on, and Dawn's admission-policy version.",
        "properties": {
          "content": {
            "$ref": "#/components/schemas/Artifact"
          },
          "evidence": {
            "items": {
              "$ref": "#/components/schemas/EntryRef"
            },
            "type": "array"
          },
          "grants": {
            "items": {
              "$ref": "#/components/schemas/Grant"
            },
            "type": "array"
          },
          "policy": {
            "type": "string"
          },
          "proof": {
            "$ref": "#/components/schemas/Proof"
          }
        },
        "required": [
          "policy",
          "content",
          "evidence",
          "grants",
          "proof"
        ],
        "title": "DeclarationFrame",
        "type": "object"
      },
      "DeclarationRecord": {
        "description": "DeclarationRecord is the retained envelope of one declaration: the worker's assertion and Dawn's authenticated admission, retained in Bytes and named by its digest in the declaration fact.",
        "properties": {
          "admission": {
            "$ref": "#/components/schemas/DeclarationAdmission"
          },
          "content": {
            "$ref": "#/components/schemas/Artifact"
          },
          "id": {
            "type": "string"
          },
          "publisher": {
            "type": "string"
          },
          "request": {
            "$ref": "#/components/schemas/DeclareRequest"
          }
        },
        "required": [
          "id",
          "request",
          "content",
          "publisher",
          "admission"
        ],
        "title": "DeclarationRecord",
        "type": "object"
      },
      "DeclareRequest": {
        "description": "DeclareRequest adds one immutable assertion about an artifact's exact content.",
        "properties": {
          "artifact": {
            "$ref": "#/components/schemas/Path"
          },
          "evidence": {
            "items": {
              "$ref": "#/components/schemas/EntryRef"
            },
            "type": "array"
          },
          "justifications": {
            "items": {
              "$ref": "#/components/schemas/Justification"
            },
            "type": "array"
          },
          "operation_id": {
            "type": "string"
          },
          "relations": {
            "items": {
              "$ref": "#/components/schemas/Relation"
            },
            "type": "array"
          },
          "statement": true,
          "subject": {
            "type": "string"
          }
        },
        "required": [
          "operation_id",
          "artifact",
          "statement"
        ],
        "title": "DeclareRequest",
        "type": "object"
      },
      "DeclareResult": {
        "description": "DeclareResult is the admitted declaration occurrence, or the first admission recovered for a retry of the same semantic request.",
        "properties": {
          "declaration": {
            "$ref": "#/components/schemas/Declaration"
          },
          "replayed": {
            "type": "boolean"
          }
        },
        "required": [
          "declaration",
          "replayed"
        ],
        "title": "DeclareResult",
        "type": "object"
      },
      "Describe": {
        "description": "Describe is the document of GET /describe.",
        "properties": {
          "bindings": {
            "$ref": "#/components/schemas/Bindings"
          },
          "build": {
            "$ref": "#/components/schemas/Build"
          },
          "contract": {
            "type": "string"
          },
          "files": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "identity": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/Identity"
              },
              {
                "type": "null"
              }
            ]
          },
          "operations": {
            "items": {
              "$ref": "#/components/schemas/Operation"
            },
            "type": "array"
          },
          "refusals": {
            "items": {
              "$ref": "#/components/schemas/Refusal"
            },
            "type": "array"
          },
          "service": {
            "type": "string"
          }
        },
        "required": [
          "service",
          "contract",
          "build",
          "bindings",
          "operations",
          "refusals",
          "files"
        ],
        "title": "Describe",
        "type": "object"
      },
      "EntriesPage": {
        "description": "EntriesPage is one page of a journal's fixed prefix (after, through].",
        "properties": {
          "entries": {
            "items": {
              "$ref": "#/components/schemas/Entry"
            },
            "type": "array"
          },
          "next_after": {
            "oneOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ]
          },
          "scanned_through": {
            "type": "integer"
          },
          "space": {
            "$ref": "#/components/schemas/Space"
          },
          "through": {
            "type": "integer"
          }
        },
        "required": [
          "space",
          "through",
          "entries",
          "scanned_through"
        ],
        "title": "EntriesPage",
        "type": "object"
      },
      "Entry": {
        "description": "Entry is one occurrence in a journal as a read returns it: its reference, origin and batch, the canonical fact bytes (base64 on the wire), and the decoded Dawn fact when the predicate is one of dawn-facts-v2.",
        "properties": {
          "attempt": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/Attempt"
              },
              {
                "type": "null"
              }
            ]
          },
          "batch": {
            "$ref": "#/components/schemas/Batch"
          },
          "bound": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/Bound"
              },
              {
                "type": "null"
              }
            ]
          },
          "child": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/Child"
              },
              {
                "type": "null"
              }
            ]
          },
          "content": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/Artifact"
              },
              {
                "type": "null"
              }
            ]
          },
          "declaration": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/Declaration"
              },
              {
                "type": "null"
              }
            ]
          },
          "fact": {
            "contentEncoding": "base64",
            "type": "string"
          },
          "justifies": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/Justifies"
              },
              {
                "type": "null"
              }
            ]
          },
          "origin": {
            "type": "string"
          },
          "produced": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/Produced"
              },
              {
                "type": "null"
              }
            ]
          },
          "record": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/Record"
              },
              {
                "type": "null"
              }
            ]
          },
          "ref": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "relation": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/RelationFact"
              },
              {
                "type": "null"
              }
            ]
          },
          "result": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/Result"
              },
              {
                "type": "null"
              }
            ]
          },
          "staged": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/Staged"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "ref",
          "origin",
          "batch",
          "fact"
        ],
        "type": "object"
      },
      "EntryRef": {
        "description": "EntryRef is the occurrence identity of one entry: a position in one journal.",
        "properties": {
          "position": {
            "type": "integer"
          },
          "root_id": {
            "type": "string"
          },
          "space_id": {
            "type": "string"
          }
        },
        "required": [
          "root_id",
          "space_id",
          "position"
        ],
        "type": "object"
      },
      "Error": {
        "description": "Error is a refusal, with the machine-readable facts the surface promises.",
        "properties": {
          "details": {
            "type": "object"
          },
          "error": {
            "type": "string"
          },
          "message": {
            "type": "string"
          }
        },
        "required": [
          "error",
          "message"
        ],
        "title": "Error",
        "type": "object"
      },
      "Event": {
        "description": "Event is one journal's advance: the space, with its path at delivery, and the committed cutoff it is now at.",
        "properties": {
          "cutoff": {
            "type": "integer"
          },
          "space": {
            "$ref": "#/components/schemas/Space"
          }
        },
        "required": [
          "space",
          "cutoff"
        ],
        "title": "Event",
        "type": "object"
      },
      "Executable": {
        "description": "Executable is what the service runs a release with, filled at bootstrap and part of the release's identity: the running service binary, its revision, and the canonical configuration the tool was prepared under.",
        "properties": {
          "configuration": {
            "type": "string"
          },
          "revision": {
            "type": "string"
          },
          "service_binary": {
            "type": "string"
          }
        },
        "required": [
          "service_binary",
          "revision",
          "configuration"
        ],
        "title": "Executable",
        "type": "object"
      },
      "ExpectedHash": {
        "description": "ExpectedHash is a publisher's hash of material: its algorithm and lower-case hex digest.",
        "properties": {
          "algorithm": {
            "type": "string"
          },
          "hex": {
            "type": "string"
          }
        },
        "required": [
          "algorithm",
          "hex"
        ],
        "type": "object"
      },
      "ExplainRequest": {
        "description": "ExplainRequest asks where an admitted assertion selected by a view comes from.",
        "properties": {
          "assertion": {
            "type": "string"
          },
          "view": {
            "$ref": "#/components/schemas/EntryRef"
          }
        },
        "required": [
          "view",
          "assertion"
        ],
        "title": "ExplainRequest",
        "type": "object"
      },
      "ExplainResult": {
        "description": "ExplainResult is the assertion's projected record, the declaration occurrence that defined it, the selection that adopted it, and the selected occurrences that disagree.",
        "properties": {
          "adopted_by": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/EntryRef"
              },
              {
                "type": "null"
              }
            ]
          },
          "assertion": {
            "type": "string"
          },
          "defined_by": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "disagreeing": {
            "items": {
              "$ref": "#/components/schemas/EntryRef"
            },
            "type": "array"
          },
          "record": true,
          "view": {
            "$ref": "#/components/schemas/EntryRef"
          }
        },
        "required": [
          "view",
          "assertion",
          "record",
          "defined_by",
          "disagreeing"
        ],
        "title": "ExplainResult",
        "type": "object"
      },
      "Export": {
        "description": "Export is a complete traversal of a selected subtree: every selected space's own journal prefix and child observation, retained in Bytes as one or more manifest chunks and cited by digest.",
        "properties": {
          "chunks": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "complete": {
            "type": "boolean"
          },
          "entries": {
            "type": "integer"
          },
          "incomplete": {
            "items": {
              "$ref": "#/components/schemas/Space"
            },
            "type": "array"
          },
          "manifest": {
            "type": "string"
          },
          "next_cursor": {
            "oneOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ]
          },
          "scope": {
            "$ref": "#/components/schemas/Space"
          },
          "spaces": {
            "type": "integer"
          }
        },
        "required": [
          "scope",
          "manifest",
          "chunks",
          "spaces",
          "entries",
          "complete",
          "incomplete"
        ],
        "title": "Export",
        "type": "object"
      },
      "Gap": {
        "description": "Gap reports a journal that advanced while the subscription's pending table was full, so the cutoff it reached was not kept.",
        "properties": {
          "space": {
            "$ref": "#/components/schemas/Space"
          }
        },
        "required": [
          "space"
        ],
        "title": "Gap",
        "type": "object"
      },
      "Grant": {
        "description": "Grant is what a principal carries to prove it may act: a kind on a subtree until an instant, issued by another principal (the root or a delegate).",
        "properties": {
          "issuer": {
            "type": "string"
          },
          "kind": {
            "type": "string"
          },
          "path": {
            "$ref": "#/components/schemas/Path"
          },
          "principal": {
            "type": "string"
          },
          "signature": {
            "description": "base64 of the 64 Ed25519 signature bytes over the fact",
            "type": "string"
          },
          "valid_until": {
            "type": "string"
          }
        },
        "required": [
          "principal",
          "kind",
          "path",
          "valid_until",
          "issuer",
          "signature"
        ],
        "type": "object"
      },
      "HTTPBinding": {
        "description": "HTTPBinding carries an operation as one request and one response.",
        "properties": {
          "method": {
            "type": "string"
          },
          "path": {
            "type": "string"
          }
        },
        "required": [
          "method",
          "path"
        ],
        "type": "object"
      },
      "Health": {
        "description": "Health is the envelope of GET /livez and GET /healthz.",
        "properties": {
          "build": {
            "$ref": "#/components/schemas/Build"
          },
          "checks": {
            "items": {
              "$ref": "#/components/schemas/Check"
            },
            "type": "array"
          },
          "contract": {
            "type": "string"
          },
          "identity": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/Identity"
              },
              {
                "type": "null"
              }
            ]
          },
          "service": {
            "type": "string"
          },
          "status": {
            "type": "string"
          },
          "time": {
            "type": "string"
          }
        },
        "required": [
          "status",
          "service",
          "contract",
          "build",
          "time",
          "checks"
        ],
        "title": "Health",
        "type": "object"
      },
      "Identity": {
        "description": "Identity is the service-specific identity member: the Journal root the world lives in, the world's own space, the Journal instance and the world's name, the space its grants are placed in.",
        "properties": {
          "journal_instance_id": {
            "type": "string"
          },
          "root_id": {
            "type": "string"
          },
          "world": {
            "type": "string"
          },
          "world_space_id": {
            "type": "string"
          }
        },
        "required": [
          "root_id",
          "world_space_id",
          "journal_instance_id"
        ],
        "type": "object"
      },
      "Justification": {
        "description": "Justification joins a group of premises that jointly justify a declaration: each premise becomes one justifies fact, and the group id joins them.",
        "properties": {
          "group": {
            "type": "string"
          },
          "method": {
            "type": "string"
          },
          "premises": {
            "items": {
              "$ref": "#/components/schemas/EntryRef"
            },
            "type": "array"
          }
        },
        "required": [
          "group",
          "premises",
          "method"
        ],
        "title": "Justification",
        "type": "object"
      },
      "Justifies": {
        "description": "Justifies is one premise that jointly justifies an assertion: the assertion id, the group joining its premises, the premise occurrence and the method.",
        "properties": {
          "assertion_id": {
            "type": "string"
          },
          "entry": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "group": {
            "type": "string"
          },
          "method": {
            "type": "string"
          },
          "premise": {
            "$ref": "#/components/schemas/EntryRef"
          }
        },
        "required": [
          "entry",
          "assertion_id",
          "group",
          "premise",
          "method"
        ],
        "type": "object"
      },
      "Manifest": {
        "description": "Manifest is an explicit selection of journal prefixes: the scope and every selected descendant with its cutoff, in depth-first preorder by child creation.",
        "properties": {
          "max_depth": {
            "oneOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ]
          },
          "scope": {
            "$ref": "#/components/schemas/Space"
          },
          "spaces": {
            "items": {
              "$ref": "#/components/schemas/ManifestSpace"
            },
            "type": "array"
          }
        },
        "required": [
          "scope",
          "max_depth",
          "spaces"
        ],
        "type": "object"
      },
      "ManifestSpace": {
        "description": "ManifestSpace is one selected space and the cutoff its entries were selected through.",
        "properties": {
          "space": {
            "$ref": "#/components/schemas/Space"
          },
          "through": {
            "type": "integer"
          }
        },
        "required": [
          "space",
          "through"
        ],
        "type": "object"
      },
      "Operation": {
        "description": "Operation is one row of the table.",
        "properties": {
          "doc": {
            "type": "string"
          },
          "errors": {
            "description": "refusals beyond invalid, unverified and denied",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "grant": {
            "description": "read | publish | declare | provision: the grant kind the operation needs; empty for operational rows",
            "type": "string"
          },
          "http": {
            "$ref": "#/components/schemas/HTTPBinding"
          },
          "kind": {
            "description": "mutation | read | stream | session | operational: the standard's operation kind",
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "params": {
            "items": {
              "$ref": "#/components/schemas/Param"
            },
            "type": "array"
          },
          "request": {
            "description": "body type; \"bytes\" for a raw stream",
            "type": "string"
          },
          "response": {
            "description": "result type; \"bytes\" for a raw stream; empty for a served file",
            "type": "string"
          },
          "ws": {
            "description": "carried by the socket as a message of the same name; streams and operational rows are HTTP only",
            "type": "boolean"
          }
        },
        "required": [
          "name",
          "kind",
          "doc",
          "params",
          "errors",
          "ws"
        ],
        "type": "object"
      },
      "OutputEntry": {
        "description": "OutputEntry is one output of a completed application: its role, ordinal within that role, the retained artifact and its occurrence.",
        "properties": {
          "artifact": {
            "$ref": "#/components/schemas/Artifact"
          },
          "entry": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "ordinal": {
            "type": "integer"
          },
          "role": {
            "type": "string"
          }
        },
        "required": [
          "role",
          "ordinal",
          "artifact",
          "entry"
        ],
        "type": "object"
      },
      "OutputManifest": {
        "description": "OutputManifest is the retained manifest of a completed application's outputs: one entry per output occurrence in role order, the counts and the coverage the tool reported.",
        "properties": {
          "application": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "counts": true,
          "coverage": true,
          "outputs": {
            "items": {
              "$ref": "#/components/schemas/OutputEntry"
            },
            "type": "array"
          }
        },
        "required": [
          "application",
          "outputs",
          "counts",
          "coverage"
        ],
        "title": "OutputManifest",
        "type": "object"
      },
      "Param": {
        "description": "Param is one named input of an operation, outside its body.",
        "properties": {
          "doc": {
            "type": "string"
          },
          "kind": {
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "required": {
            "type": "boolean"
          }
        },
        "required": [
          "name",
          "kind",
          "required",
          "doc"
        ],
        "type": "object"
      },
      "Path": {
        "description": "Path is a location in the world: labels from a root organizer down, relative to the world.",
        "items": {
          "type": "string"
        },
        "type": "array"
      },
      "Permission": {
        "description": "Permission is one grant a provisioning asks for: a kind on a subtree.",
        "properties": {
          "kind": {
            "type": "string"
          },
          "path": {
            "$ref": "#/components/schemas/Path"
          }
        },
        "required": [
          "kind",
          "path"
        ],
        "type": "object"
      },
      "Produced": {
        "description": "Produced is one output occurrence of the application named by application.",
        "properties": {
          "application": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "entry": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "produced": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "role": {
            "type": "string"
          }
        },
        "required": [
          "entry",
          "application",
          "role",
          "produced"
        ],
        "type": "object"
      },
      "Proof": {
        "description": "Proof authenticates one request attempt: the principal, a fresh nonce, the instant, the audience the proof is meant for, and the signature over the signing record.",
        "properties": {
          "audience": {
            "type": "string"
          },
          "nonce": {
            "type": "string"
          },
          "principal": {
            "type": "string"
          },
          "signature": {
            "description": "base64 of the 64 Ed25519 signature bytes",
            "type": "string"
          },
          "timestamp": {
            "type": "string"
          }
        },
        "required": [
          "principal",
          "nonce",
          "timestamp",
          "audience",
          "signature"
        ],
        "type": "object"
      },
      "ProvisionWorkerRequest": {
        "description": "ProvisionWorkerRequest creates a worker space under its project and issues its grants to a public key the provisioner generated into the workspace.",
        "properties": {
          "operation_id": {
            "type": "string"
          },
          "permissions": {
            "items": {
              "$ref": "#/components/schemas/Permission"
            },
            "type": "array"
          },
          "principal": {
            "type": "string"
          },
          "project": {
            "type": "string"
          },
          "valid_until": {
            "type": "string"
          },
          "worker": {
            "type": "string"
          }
        },
        "required": [
          "operation_id",
          "project",
          "worker",
          "principal",
          "permissions",
          "valid_until"
        ],
        "title": "ProvisionWorkerRequest",
        "type": "object"
      },
      "ProvisionWorkerResult": {
        "description": "ProvisionWorkerResult is the worker's space, its initial state record, the grants and the workspace material.",
        "properties": {
          "grants": {
            "items": {
              "$ref": "#/components/schemas/Grant"
            },
            "type": "array"
          },
          "replayed": {
            "type": "boolean"
          },
          "space": {
            "$ref": "#/components/schemas/Space"
          },
          "state": {
            "$ref": "#/components/schemas/Record"
          },
          "workspace": {
            "$ref": "#/components/schemas/Workspace"
          }
        },
        "required": [
          "space",
          "state",
          "grants",
          "workspace",
          "replayed"
        ],
        "title": "ProvisionWorkerResult",
        "type": "object"
      },
      "PublishRequest": {
        "description": "PublishRequest appends a record to the individual record's leaf journal at path, creating the leaf under its organizer when absent.",
        "properties": {
          "expected_cutoff": {
            "oneOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ]
          },
          "metadata": {
            "additionalProperties": {
              "type": "string"
            },
            "type": "object"
          },
          "operation_id": {
            "type": "string"
          },
          "path": {
            "$ref": "#/components/schemas/Path"
          },
          "profile": {
            "type": "string"
          },
          "record": true
        },
        "required": [
          "operation_id",
          "path",
          "profile",
          "record"
        ],
        "title": "PublishRequest",
        "type": "object"
      },
      "PublishResult": {
        "description": "PublishResult is the accepted or recovered outcome: the record occurrence, whether this operation created the leaf journal, and whether the result was recovered from an earlier admission of the same request.",
        "properties": {
          "record": {
            "$ref": "#/components/schemas/Record"
          },
          "replayed": {
            "type": "boolean"
          },
          "space_created": {
            "type": "boolean"
          }
        },
        "required": [
          "record",
          "space_created",
          "replayed"
        ],
        "title": "PublishResult",
        "type": "object"
      },
      "QueryRequest": {
        "description": "QueryRequest asks a view occurrence for records.",
        "properties": {
          "cursor": {
            "oneOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ]
          },
          "filters": true,
          "limit": {
            "type": "integer"
          },
          "view": {
            "$ref": "#/components/schemas/EntryRef"
          }
        },
        "required": [
          "view",
          "filters"
        ],
        "title": "QueryRequest",
        "type": "object"
      },
      "QueryResult": {
        "description": "QueryResult carries records with the view, coverage and limits it holds for.",
        "properties": {
          "coverage": true,
          "limits": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "next_cursor": {
            "oneOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ]
          },
          "outcome": {
            "type": "string"
          },
          "records": {
            "items": true,
            "type": "array"
          },
          "view": {
            "$ref": "#/components/schemas/EntryRef"
          }
        },
        "required": [
          "view",
          "outcome",
          "records",
          "coverage",
          "limits"
        ],
        "title": "QueryResult",
        "type": "object"
      },
      "Record": {
        "description": "Record is one admitted record occurrence: the fact Dawn appended to an individual record's leaf journal under dawn-facts-v2, with the provenance Dawn persists because Journal supplies none.",
        "properties": {
          "accepted_at": {
            "type": "string"
          },
          "entry": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "hash": {
            "type": "string"
          },
          "metadata": {
            "additionalProperties": {
              "type": "string"
            },
            "type": "object"
          },
          "profile": {
            "type": "string"
          },
          "publisher": {
            "type": "string"
          },
          "request_digest": {
            "type": "string"
          },
          "request_id": {
            "type": "string"
          }
        },
        "required": [
          "entry",
          "profile",
          "hash",
          "metadata",
          "publisher",
          "request_id",
          "request_digest",
          "accepted_at"
        ],
        "title": "Record",
        "type": "object"
      },
      "RecordRead": {
        "description": "RecordRead is one exact occurrence, read by its reference at a valid covering cutoff, with the space it lies in resolved to its Dawn path.",
        "properties": {
          "entry": {
            "$ref": "#/components/schemas/Entry"
          },
          "space": {
            "$ref": "#/components/schemas/Space"
          }
        },
        "required": [
          "space",
          "entry"
        ],
        "title": "RecordRead",
        "type": "object"
      },
      "Refusal": {
        "description": "RefusalRecord is the retained payload of a dawn/refusal/1 record: an authenticated, well-formed request that could not be applied, with the reason, written under the application leaf in place of an attempt.",
        "properties": {
          "publisher": {
            "type": "string"
          },
          "reason": {
            "type": "string"
          },
          "refused_at": {
            "type": "string"
          },
          "request": true
        },
        "required": [
          "request",
          "reason",
          "publisher",
          "refused_at"
        ],
        "title": "Refusal",
        "type": "object"
      },
      "Relation": {
        "description": "Relation names a declaration's relation to another occurrence: supersedes, challenges or withdraws.",
        "properties": {
          "kind": {
            "type": "string"
          },
          "target": {
            "$ref": "#/components/schemas/EntryRef"
          }
        },
        "required": [
          "kind",
          "target"
        ],
        "title": "Relation",
        "type": "object"
      },
      "RelationFact": {
        "description": "RelationFact is one relation of an assertion to another occurrence: supersedes, challenges or withdraws.",
        "properties": {
          "assertion_id": {
            "type": "string"
          },
          "entry": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "kind": {
            "type": "string"
          },
          "target": {
            "$ref": "#/components/schemas/EntryRef"
          }
        },
        "required": [
          "entry",
          "assertion_id",
          "kind",
          "target"
        ],
        "type": "object"
      },
      "ResolveResult": {
        "description": "ResolveResult is the space at a path, or null when the path is unoccupied.",
        "properties": {
          "space": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/Space"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "space"
        ],
        "title": "ResolveResult",
        "type": "object"
      },
      "Result": {
        "description": "Result is the seal fact of a terminal application: its outcome, the retained manifest, resolution and seal envelope by hash.",
        "properties": {
          "application": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "attestation": {
            "type": "string"
          },
          "entry": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "manifest": {
            "type": "string"
          },
          "outcome": {
            "type": "string"
          },
          "resolution": {
            "type": "string"
          }
        },
        "required": [
          "entry",
          "application",
          "outcome",
          "manifest",
          "resolution",
          "attestation"
        ],
        "type": "object"
      },
      "ResultSeal": {
        "description": "ResultSeal is the retained, signed envelope of a terminal application: the application and release, every bound and produced occurrence, the outcome, the retained environment, manifest and resolution, and the service root's signature over the canonical seal with the signature empty.",
        "properties": {
          "application": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "bound": {
            "items": {
              "$ref": "#/components/schemas/EntryRef"
            },
            "type": "array"
          },
          "environment": {
            "type": "string"
          },
          "manifest": {
            "type": "string"
          },
          "outcome": {
            "type": "string"
          },
          "produced": {
            "items": {
              "$ref": "#/components/schemas/EntryRef"
            },
            "type": "array"
          },
          "release": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "resolution": {
            "type": "string"
          },
          "signature": {
            "type": "string"
          },
          "signed_at": {
            "type": "string"
          }
        },
        "required": [
          "application",
          "release",
          "bound",
          "produced",
          "outcome",
          "environment",
          "manifest",
          "resolution",
          "signed_at",
          "signature"
        ],
        "title": "ResultSeal",
        "type": "object"
      },
      "RetainResult": {
        "description": "RetainResult names bytes that were retained and verified.",
        "properties": {
          "artifact": {
            "$ref": "#/components/schemas/Artifact"
          },
          "size": {
            "type": "integer"
          }
        },
        "required": [
          "artifact",
          "size"
        ],
        "title": "RetainResult",
        "type": "object"
      },
      "RetireWorkerRequest": {
        "description": "RetireWorkerRequest records that a worker's window is closed.",
        "properties": {
          "operation_id": {
            "type": "string"
          },
          "project": {
            "type": "string"
          },
          "worker": {
            "type": "string"
          }
        },
        "required": [
          "operation_id",
          "project",
          "worker"
        ],
        "title": "RetireWorkerRequest",
        "type": "object"
      },
      "Role": {
        "description": "Role is one declared input or output of a tool.",
        "properties": {
          "accepts": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "doc": {
            "type": "string"
          },
          "dynamic": {
            "type": "boolean"
          },
          "name": {
            "type": "string"
          },
          "required": {
            "type": "boolean"
          },
          "yields": {
            "type": "string"
          }
        },
        "required": [
          "name",
          "doc"
        ],
        "title": "Role",
        "type": "object"
      },
      "Snapshot": {
        "description": "Snapshot is a captured manifest, retained in Bytes as canonical JSON and cited by that digest.",
        "properties": {
          "digest": {
            "type": "string"
          },
          "manifest": {
            "$ref": "#/components/schemas/Manifest"
          }
        },
        "required": [
          "manifest",
          "digest"
        ],
        "title": "Snapshot",
        "type": "object"
      },
      "Space": {
        "description": "Space is a space's identity together with its Dawn path: the labels below the world, so a grant by path applies to it.",
        "properties": {
          "path": {
            "$ref": "#/components/schemas/Path"
          },
          "root_id": {
            "type": "string"
          },
          "space_id": {
            "type": "string"
          }
        },
        "required": [
          "root_id",
          "space_id",
          "path"
        ],
        "type": "object"
      },
      "SpaceRef": {
        "description": "SpaceRef is the exact identity of one space and its journal, as Journal allocated it.",
        "properties": {
          "root_id": {
            "type": "string"
          },
          "space_id": {
            "type": "string"
          }
        },
        "required": [
          "root_id",
          "space_id"
        ],
        "type": "object"
      },
      "SpaceResult": {
        "description": "SpaceResult is the outcome of creating structure without a record.",
        "properties": {
          "replayed": {
            "type": "boolean"
          },
          "space": {
            "$ref": "#/components/schemas/Space"
          }
        },
        "required": [
          "space",
          "replayed"
        ],
        "title": "SpaceResult",
        "type": "object"
      },
      "Staged": {
        "description": "Staged is the first fact of an artifact space an application creates, before its content fact, naming the application.",
        "properties": {
          "application": {
            "$ref": "#/components/schemas/EntryRef"
          },
          "entry": {
            "$ref": "#/components/schemas/EntryRef"
          }
        },
        "required": [
          "entry",
          "application"
        ],
        "type": "object"
      },
      "SubscribeRequest": {
        "description": "SubscribeRequest opens a subscription over a scope.",
        "properties": {
          "scope": {
            "$ref": "#/components/schemas/Path"
          }
        },
        "required": [
          "scope"
        ],
        "title": "SubscribeRequest",
        "type": "object"
      },
      "SubscribeResult": {
        "description": "SubscribeResult reports the open subscription.",
        "properties": {
          "expires_at": {
            "description": "ExpiresAt is when the service stops delivering: the earlier of the\ngrant's validity end and the configured maximum. Renewal is a fresh\nsubscribe with a fresh proof, because events carry no proof of their own.",
            "type": "string"
          },
          "scope": {
            "$ref": "#/components/schemas/Space"
          },
          "subscription": {
            "type": "string"
          }
        },
        "required": [
          "subscription",
          "scope",
          "expires_at"
        ],
        "title": "SubscribeResult",
        "type": "object"
      },
      "SubscriptionClosed": {
        "description": "SubscriptionClosed is the last frame of a subscription.",
        "properties": {
          "delivered": {
            "type": "integer"
          },
          "reason": {
            "type": "string"
          }
        },
        "required": [
          "reason",
          "delivered"
        ],
        "title": "SubscriptionClosed",
        "type": "object"
      },
      "ToolDescription": {
        "description": "ToolDescription is the retained content of a release's artifact space under the world's tools: what the tool is, what it takes and yields, whether running it twice on one valuation is expected to agree, which hosts it may reach, and how the service executes it.",
        "properties": {
          "class": {
            "type": "string"
          },
          "deterministic": {
            "type": "boolean"
          },
          "doc": {
            "type": "string"
          },
          "effects": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "egress": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "executable": {
            "$ref": "#/components/schemas/Executable"
          },
          "inputs": {
            "items": {
              "$ref": "#/components/schemas/Role"
            },
            "type": "array"
          },
          "name": {
            "type": "string"
          },
          "outputs": {
            "items": {
              "$ref": "#/components/schemas/Role"
            },
            "type": "array"
          },
          "recipe_doc": {
            "type": "string"
          },
          "version": {
            "type": "string"
          }
        },
        "required": [
          "name",
          "version",
          "doc",
          "class",
          "inputs",
          "outputs",
          "effects",
          "recipe_doc",
          "deterministic",
          "egress",
          "executable"
        ],
        "title": "ToolDescription",
        "type": "object"
      },
      "UnsubscribeResult": {
        "description": "UnsubscribeResult reports a closed subscription.",
        "properties": {
          "delivered": {
            "type": "integer"
          },
          "subscription": {
            "type": "string"
          }
        },
        "required": [
          "subscription",
          "delivered"
        ],
        "title": "UnsubscribeResult",
        "type": "object"
      },
      "Workspace": {
        "description": "Workspace is what a prepared directory needs to know: the endpoint, the audience its proofs name, its principal and its path; never a backend.",
        "properties": {
          "audience": {
            "type": "string"
          },
          "endpoint": {
            "type": "string"
          },
          "path": {
            "$ref": "#/components/schemas/Path"
          },
          "principal": {
            "type": "string"
          },
          "project": {
            "type": "string"
          },
          "worker": {
            "type": "string"
          }
        },
        "required": [
          "endpoint",
          "audience",
          "principal",
          "project",
          "worker",
          "path"
        ],
        "type": "object"
      }
    }
  },
  "info": {
    "description": "Generated from api.Operations and the api package's types (ulab-standard/API.md). The contract is SURFACE.md, HTTP.md and WS.md: the signing record, grants, the record admission protocol, consistency and cancellation live there and not here. Every operation marked x-ulab-ws-message is also carried by the WebSocket binding of WS.md as a message of that name.",
    "title": "dawn",
    "version": "2026-09-19"
  },
  "openapi": "3.1.0",
  "paths": {
    "/describe": {
      "get": {
        "operationId": "describe",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Describe"
                }
              }
            },
            "description": "the result"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid"
          }
        },
        "summary": "who this is, which contract, build, identity, bindings, operations, refusals and served files",
        "tags": [
          "operational"
        ]
      }
    },
    "/describe/{file}": {
      "get": {
        "operationId": "describe_file",
        "parameters": [
          {
            "description": "a file name listed by describe",
            "in": "path",
            "name": "file",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "the file, verbatim, as text/markdown or application/json"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          }
        },
        "summary": "one committed contract file, verbatim, with its media type",
        "tags": [
          "operational"
        ]
      }
    },
    "/healthz": {
      "get": {
        "operationId": "health",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Health"
                }
              }
            },
            "description": "the result"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Health"
                }
              }
            },
            "description": "failing: the same envelope with the failing checks"
          }
        },
        "summary": "the service can serve its contract: journal and bytes answer; 503 otherwise",
        "tags": [
          "operational"
        ]
      }
    },
    "/livez": {
      "get": {
        "operationId": "livez",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Health"
                }
              }
            },
            "description": "the result"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid"
          }
        },
        "summary": "the process is up and can answer; never 503; empty checks",
        "tags": [
          "operational"
        ]
      }
    },
    "/v1/applications": {
      "post": {
        "operationId": "apply",
        "parameters": [
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ApplyRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ApplyResult"
                }
              }
            },
            "description": "replayed: the original result of this operation ID, or a read-like result"
          },
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ApplyResult"
                }
              }
            },
            "description": "accepted"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid, invalid_record, structural"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "conflict, exists, idempotency_mismatch, unresolved"
          },
          "413": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "limit_exceeded"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "run a configured tool on a valuation of its input roles and record the application: admit the attempt, create the output artifacts, append the application batch and attest the run; recover an earlier admission of the same request",
        "tags": [
          "mutation"
        ],
        "x-dawn-grant": "publish",
        "x-ulab-ws-message": "apply"
      }
    },
    "/v1/artifacts": {
      "post": {
        "operationId": "create_artifact",
        "parameters": [
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreateArtifactRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ArtifactResult"
                }
              }
            },
            "description": "replayed: the original result of this operation ID, or a read-like result"
          },
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ArtifactResult"
                }
              }
            },
            "description": "accepted"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid, invalid_record, structural"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "conflict, exists, idempotency_mismatch, unresolved"
          },
          "413": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "limit_exceeded"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "create an artifact space with its one immutable content fact and its declarations space",
        "tags": [
          "mutation"
        ],
        "x-dawn-grant": "publish",
        "x-ulab-ws-message": "create_artifact"
      }
    },
    "/v1/assignments": {
      "post": {
        "operationId": "assign",
        "parameters": [
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AssignRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PublishResult"
                }
              }
            },
            "description": "replayed: the original result of this operation ID, or a read-like result"
          },
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PublishResult"
                }
              }
            },
            "description": "accepted"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid, structural"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "conflict, exists, idempotency_mismatch, unresolved"
          },
          "413": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "limit_exceeded"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "publish an assignment: pinned inputs and intended outputs for a worker",
        "tags": [
          "mutation"
        ],
        "x-dawn-grant": "provision",
        "x-ulab-ws-message": "assign"
      }
    },
    "/v1/campaigns": {
      "post": {
        "operationId": "create_campaign",
        "parameters": [
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreateCampaignRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PublishResult"
                }
              }
            },
            "description": "replayed: the original result of this operation ID, or a read-like result"
          },
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PublishResult"
                }
              }
            },
            "description": "accepted"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid, structural"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "conflict, exists, idempotency_mismatch"
          },
          "413": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "limit_exceeded"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "create a campaign space over a project with its state record",
        "tags": [
          "mutation"
        ],
        "x-dawn-grant": "provision",
        "x-ulab-ws-message": "create_campaign"
      }
    },
    "/v1/children": {
      "get": {
        "operationId": "children",
        "parameters": [
          {
            "description": "the path, one label per entry, below the world; omitted selects the world itself",
            "explode": true,
            "in": "query",
            "name": "path",
            "required": false,
            "schema": {
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "description": "a cutoff of the selected journal; omitted captures its committed cutoff once; a continuation resends it",
            "in": "query",
            "name": "through",
            "required": false,
            "schema": {
              "type": "integer"
            }
          },
          {
            "description": "a continuation cursor from the previous page",
            "in": "query",
            "name": "cursor",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "page size, 1..128, default 64",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "type": "integer"
            }
          },
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ChildrenPage"
                }
              }
            },
            "description": "the result"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid, invalid_cursor"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "413": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "limit_exceeded"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "the readable children of a space at a fixed cutoff, in creation order; without a path, the world's",
        "tags": [
          "read"
        ],
        "x-dawn-grant": "read",
        "x-ulab-ws-message": "children"
      }
    },
    "/v1/compose": {
      "post": {
        "operationId": "compose",
        "parameters": [
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ComposeRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PublishResult"
                }
              }
            },
            "description": "replayed: the original result of this operation ID, or a read-like result"
          },
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PublishResult"
                }
              }
            },
            "description": "accepted"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid, invalid_record, structural"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "conflict, exists, idempotency_mismatch, unresolved"
          },
          "413": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "limit_exceeded"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "compose a view from exact occurrence selections and publish it under views/",
        "tags": [
          "mutation"
        ],
        "x-dawn-grant": "publish",
        "x-ulab-ws-message": "compose"
      }
    },
    "/v1/declarations": {
      "post": {
        "operationId": "declare",
        "parameters": [
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DeclareRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DeclareResult"
                }
              }
            },
            "description": "replayed: the original result of this operation ID, or a read-like result"
          },
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DeclareResult"
                }
              }
            },
            "description": "accepted"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid, invalid_record, structural"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "conflict, exists, idempotency_mismatch, unresolved"
          },
          "413": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "limit_exceeded"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "append an immutable attributed declaration about an artifact's exact content, retaining the signed envelope and its frame and recovering the first admission on retry",
        "tags": [
          "mutation"
        ],
        "x-dawn-grant": "declare",
        "x-ulab-ws-message": "declare"
      }
    },
    "/v1/entries": {
      "get": {
        "operationId": "entries",
        "parameters": [
          {
            "description": "the path, one label per entry, below the world",
            "explode": true,
            "in": "query",
            "name": "path",
            "required": true,
            "schema": {
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "description": "the position a page continues after; omitted starts at the beginning",
            "in": "query",
            "name": "after",
            "required": false,
            "schema": {
              "type": "integer"
            }
          },
          {
            "description": "a cutoff of the selected journal; omitted captures its committed cutoff once; a continuation resends it",
            "in": "query",
            "name": "through",
            "required": false,
            "schema": {
              "type": "integer"
            }
          },
          {
            "description": "page size, 1..128, default 64",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "type": "integer"
            }
          },
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/EntriesPage"
                }
              }
            },
            "description": "the result"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid, invalid_cursor"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "413": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "limit_exceeded"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "a journal's entries over a fixed prefix, ascending, one page at a time",
        "tags": [
          "read"
        ],
        "x-dawn-grant": "read",
        "x-ulab-ws-message": "entries"
      }
    },
    "/v1/explain": {
      "post": {
        "operationId": "explain",
        "parameters": [
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ExplainRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ExplainResult"
                }
              }
            },
            "description": "the result"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unresolved"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "an admitted assertion at a view: which declaration defined it, which selection adopted it, what disagreed",
        "tags": [
          "read"
        ],
        "x-dawn-grant": "read",
        "x-ulab-ws-message": "explain"
      }
    },
    "/v1/export": {
      "get": {
        "operationId": "export",
        "parameters": [
          {
            "description": "the path, one label per entry, below the world; omitted selects the world itself",
            "explode": true,
            "in": "query",
            "name": "path",
            "required": false,
            "schema": {
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "description": "a continuation cursor from the previous page",
            "in": "query",
            "name": "cursor",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Export"
                }
              }
            },
            "description": "the result"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid, invalid_cursor"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "413": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "limit_exceeded"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "a complete traversal of the world or a subtree: every selected journal prefix and child observation, retained in bytes and cited by digest, with explicit incomplete coverage",
        "tags": [
          "read"
        ],
        "x-dawn-grant": "provision",
        "x-ulab-ws-message": "export"
      }
    },
    "/v1/fetch": {
      "get": {
        "operationId": "fetch",
        "parameters": [
          {
            "description": "the path, one label per entry, below the world",
            "explode": true,
            "in": "query",
            "name": "path",
            "required": true,
            "schema": {
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "description": "the hash of the retained bytes",
            "in": "query",
            "name": "bytes",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/octet-stream": {
                "schema": {
                  "format": "binary",
                  "type": "string"
                }
              }
            },
            "description": "the result"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unresolved"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "the bytes of retained content the path's journal names, streamed and verified before completion",
        "tags": [
          "stream"
        ],
        "x-dawn-grant": "read"
      }
    },
    "/v1/get": {
      "get": {
        "operationId": "get",
        "parameters": [
          {
            "description": "the Journal root the occurrence lies in",
            "in": "query",
            "name": "root_id",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "the exact space the occurrence lies in",
            "in": "query",
            "name": "space_id",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "the occurrence's position in its journal",
            "in": "query",
            "name": "position",
            "required": true,
            "schema": {
              "type": "integer"
            }
          },
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/RecordRead"
                }
              }
            },
            "description": "the result"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "one exact occurrence by its reference, read at a valid covering cutoff; the reference is resolved to its actual path before authorization",
        "tags": [
          "read"
        ],
        "x-dawn-grant": "read",
        "x-ulab-ws-message": "get"
      }
    },
    "/v1/projects": {
      "post": {
        "operationId": "create_project",
        "parameters": [
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreateProjectRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/SpaceResult"
                }
              }
            },
            "description": "replayed: the original result of this operation ID, or a read-like result"
          },
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/SpaceResult"
                }
              }
            },
            "description": "accepted"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid, structural"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "conflict, exists, idempotency_mismatch"
          },
          "413": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "limit_exceeded"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "create a project space with its organizing spaces",
        "tags": [
          "mutation"
        ],
        "x-dawn-grant": "provision",
        "x-ulab-ws-message": "create_project"
      }
    },
    "/v1/publish": {
      "post": {
        "operationId": "publish",
        "parameters": [
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/PublishRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PublishResult"
                }
              }
            },
            "description": "replayed: the original result of this operation ID, or a read-like result"
          },
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PublishResult"
                }
              }
            },
            "description": "accepted"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid, invalid_record, structural"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "conflict, exists, idempotency_mismatch, unresolved"
          },
          "413": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "limit_exceeded"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "publish a record at a path: validate, retain, append the record fact to the leaf journal with its admission provenance, recovering an earlier admission of the same request",
        "tags": [
          "mutation"
        ],
        "x-dawn-grant": "publish",
        "x-ulab-ws-message": "publish"
      }
    },
    "/v1/query": {
      "post": {
        "operationId": "query",
        "parameters": [
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/QueryRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/QueryResult"
                }
              }
            },
            "description": "the result"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid, invalid_cursor"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unresolved"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "records of a view matching filters, with the view, coverage and limits; four outcomes kept apart",
        "tags": [
          "read"
        ],
        "x-dawn-grant": "read",
        "x-ulab-ws-message": "query"
      }
    },
    "/v1/resolve": {
      "get": {
        "operationId": "resolve",
        "parameters": [
          {
            "description": "the path, one label per entry, below the world",
            "explode": true,
            "in": "query",
            "name": "path",
            "required": true,
            "schema": {
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ResolveResult"
                }
              }
            },
            "description": "the result"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "the space at a path, or null when the path is unoccupied",
        "tags": [
          "read"
        ],
        "x-dawn-grant": "read",
        "x-ulab-ws-message": "resolve"
      }
    },
    "/v1/retain": {
      "put": {
        "operationId": "retain",
        "parameters": [
          {
            "description": "the path, one label per entry, below the world",
            "explode": true,
            "in": "query",
            "name": "path",
            "required": true,
            "schema": {
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "description": "the interpretation hash the bytes are retained under",
            "in": "query",
            "name": "type",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/octet-stream": {
              "schema": {
                "format": "binary",
                "type": "string"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/RetainResult"
                }
              }
            },
            "description": "replayed: the original result of this operation ID, or a read-like result"
          },
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/RetainResult"
                }
              }
            },
            "description": "accepted"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid, invalid_record"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "retain bytes under a declared interpretation; nothing is named yet; verified against the hash before the artifact is reported",
        "tags": [
          "mutation"
        ],
        "x-dawn-grant": "publish"
      }
    },
    "/v1/snapshot": {
      "get": {
        "operationId": "snapshot",
        "parameters": [
          {
            "description": "the path, one label per entry, below the world; omitted selects the world itself",
            "explode": true,
            "in": "query",
            "name": "path",
            "required": false,
            "schema": {
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "description": "how many levels below the scope to select; omitted selects every descendant",
            "in": "query",
            "name": "depth",
            "required": false,
            "schema": {
              "type": "integer"
            }
          },
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Snapshot"
                }
              }
            },
            "description": "the result"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "413": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "limit_exceeded"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "capture an explicit manifest of the scope and its selected descendants, retained in bytes and cited by digest",
        "tags": [
          "read"
        ],
        "x-dawn-grant": "read",
        "x-ulab-ws-message": "snapshot"
      }
    },
    "/v1/workers": {
      "post": {
        "operationId": "provision_worker",
        "parameters": [
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ProvisionWorkerRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ProvisionWorkerResult"
                }
              }
            },
            "description": "replayed: the original result of this operation ID, or a read-like result"
          },
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ProvisionWorkerResult"
                }
              }
            },
            "description": "accepted"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid, structural"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "conflict, exists, idempotency_mismatch"
          },
          "413": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "limit_exceeded"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "create a worker space under its project, write its state record and issue its grants to the workspace's public key",
        "tags": [
          "mutation"
        ],
        "x-dawn-grant": "provision",
        "x-ulab-ws-message": "provision_worker"
      }
    },
    "/v1/workers/retire": {
      "post": {
        "operationId": "retire_worker",
        "parameters": [
          {
            "description": "base64 of the JSON Carriage: the principal's proof over the signing record of this call and the grants it relies on (SURFACE.md, HTTP.md)",
            "in": "header",
            "name": "Dawn-Auth",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/RetireWorkerRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PublishResult"
                }
              }
            },
            "description": "replayed: the original result of this operation ID, or a read-like result"
          },
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PublishResult"
                }
              }
            },
            "description": "accepted"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "invalid, structural"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unverified"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "denied"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "not_found"
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "conflict, exists, idempotency_mismatch"
          },
          "413": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "limit_exceeded"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            },
            "description": "unavailable"
          }
        },
        "summary": "record that a worker's window is closed",
        "tags": [
          "mutation"
        ],
        "x-dawn-grant": "provision",
        "x-ulab-ws-message": "retire_worker"
      }
    }
  },
  "servers": [
    {
      "description": "the standalone default listener",
      "url": "http://127.0.0.1:8091"
    }
  ]
}