Skip to content

Namespaces, writer policies and session keys

Every message on an app chain names a topic, such as freight/acme/shipments. On any chain the topic is a label. On a chain sealed with a topics: block, a topic registry in the chain’s state also decides who may write each topic, and every member enforces it before any state machine sees the message. Yano owns the registry, its checks and its proofs; Yano X supplies the appchain topics commands, the clients and the composite rules.

The examples on this page follow one chain: a freight consortium whose members share delivery records. The consortium owns the freight/ namespace, each member company runs its own namespace below it, and Acme’s drivers record delivery scans on freight/acme/shipments from a web app.

One topic name, used everywhereConcept
ON EVERY CHAINWITH A TOPIC REGISTRYfreight/acme/shipmentsone topic nameRoute & filtermany topics per chainRead & streamby-topic queries, SSESubmit accesstopic-scoped API keysEncrypted bodiesa key per topicWho may writewriter keys or openSession keysdelegated by a writerPayload rulessize limit and schemaComposite rulescheck writer, payloadalwayswhen sealed with topics:ON EVERY CHAINWITH A TOPIC REGISTRYfreight/acme/shipmentsone topic nameRoute & filtermany topics per chainRead & streamby-topic queries, SSESubmit accesstopic-scoped API keysEncrypted bodiesa key per topicWho may writewriter keys or openSession keysdelegated by a writerPayload rulessize limit and schemaComposite rulescheck writer, payload
  • On every chain: Route & filter, Read & stream, Submit access, Encrypted bodies.
  • With a topic registry: Who may write, Session keys, Payload rules, Composite rules.
  • freight/acme/shipments → On every chain (always).
  • freight/acme/shipments → With a topic registry (when sealed with topics:).
freight/acme/shipments
Every message names a topic when it is submitted: POST /messages with {"topic": …, "body": …}. Here, a freight consortium's chain carries Acme's delivery scans on freight/acme/shipments. Topics starting with ~ are reserved for the system.
Route & filter
The topic is a label for routing and filtering. It does not create a separate log: one chain can carry many topics, and a composite chain gives each component its topic.
Read & stream
GET /messages/by-topic/{topic} lists finalized messages on a topic, GET /stream?topic= streams them live, and the Java client's @AppChainListener(topic = …) receives them.
Submit access
An API key written as key=topicA|topicB may submit only to those topics. This controls who may use a node's REST API; the node still signs the envelope with its own member key.
Encrypted bodies
Bodies can be encrypted with AES-256-GCM and the topic as associated data, so a key for one topic cannot open another topic's messages.
Who may write
The topic's policy names its writers: open, or a threshold of writer keys. A write on a protected topic carries their signatures, and every member checks them before the message can enter a block.
Session keys
A writer listed under delegate can sign a short-lived credential for a user's session key, so a browser writes without holding the writer key.
Payload rules
maxPayloadBytes and an optional CBOR schema are checked on every member, even on open topics.
Composite rules
Admission rules of a composite chain can read writer.kind, writer.signers and payload.*: the verified writer and payload, after the topic policy passed.
On every chain the topic routes, filters and scopes access. On a chain sealed with topics:, the topic registry also decides who may write it, and every member enforces that before any state machine sees the message.
  • on every chain
  • enforced by the topic registry

A chain gets a registry from its draft: add topics: to the chain (./yano.sh appchain new --topics <chain>=members, or answer the wizard), with governed membership. It is sealed into the chain’s genesis; see configure an application. Without it, topics work as before and anyone who can submit to a node may write any topic.

Who registers, manages and writesConcept
CREATE A NAMESPACETOPIC REGISTRYMembers votecreate: membersRegistrars signcreate: registrarsAnyone claimscreate: anyoneNamespace ownersk-of-n owner keysUncovered topicsopen or rejectfreight/top-level namespacefreight/acme/child: overrides fieldsfreight/acme/shipmentsa topic: messages go hereLogin servicea writer in delegateSession keyin the driver's appWritersk-of-n writer keyscreatemanagecredentialCREATE A NAMESPACETOPIC REGISTRYMembers votecreate: membersRegistrars signcreate: registrarsAnyone claimscreate: anyoneNamespace ownersk-of-n owner keysUncovered topicsopen or rejectfreight/top-level namespacefreight/acme/child: overridesfreight/acme/shipmentsa topicLogin servicea writer in delegateSession keyin the driver's appWritersk-of-n writer keys
  • Create a namespace: Members vote, Registrars sign, Anyone claims.
  • Topic registry: freight/, freight/acme/, freight/acme/shipments.
  • Create a namespace → freight/ (create).
  • Namespace owners → freight/acme/ (manage).
  • freight/ → freight/acme/.
  • freight/acme/ → freight/acme/shipments.
  • Login service → Session key (credential).
  • Session key → freight/acme/shipments.
  • Writers → freight/acme/shipments.
Members vote
Each operator runs topics approve <plan> on their own node. The namespace is created once the chain's block threshold of members has voted and the activation lag has passed. The members can always create or recover a namespace by vote, whatever else the draft allows.
Registrars sign
Keys named in the draft sign a creation with authority ~registrars, without a vote. A registrar named by operator signs with that operator's member key; name a separate public key to keep them apart. Registrars create top-level names only.
Anyone claims
The first claim for an unused single-segment name wins. The claim is signed by the owners it names (authority ~claim).
Namespace owners
The owners of a namespace create entries below it, change their policies, rotate the owner set, retire entries and revoke credentials, with topics plan, sign and submit. Here the consortium owns freight/ and creates freight/acme/ with Acme's operations and security keys as its owners; from then on Acme runs its own topics. A change takes effect at a later height, never retroactively.
Uncovered topics
A topic that no entry covers follows the draft's unregistered: setting. open, which appchain new writes, accepts it as on a chain without topics; reject refuses it with TOPIC_UNREGISTERED. Topics starting with ~ are system topics with their own rules.
freight/
A namespace ends in / and covers every topic below it. Its entry holds the owners and a policy: writers, delegate, maxDelegationMs, maxPayloadBytes and a schema. The consortium sets defaults here, such as a 4 KB payload limit, that every member company inherits.
freight/acme/
The longest matching entry wins. A child entry can override single policy fields; an omitted field inherits from freight/. writers: open, an empty delegate list and schema: none are explicit overrides. Retirement is inherited, and a child cannot undo it.
freight/acme/shipments
Acme's delivery scans. Every message on this topic is checked against its effective policy, on every member, before it can enter a block.
Login service
An application service whose key is a writer and is listed under delegate, such as Acme's driver login behind its corporate SSO. After it signs a driver in, it signs a short-lived credential for the driver's session key and one scope. Delegation works only with a 1-of-n writer set: a credential stands in for one writer.
Session key
A non-extractable WebCrypto key that the driver's web app makes. It signs each scan, and the write carries the issuer's credential. The credential lasts at most maxDelegationMs and the chain's limit (one hour by default), and the owners or the issuer can revoke it.
Writers
A service holding writer keys signs each write itself, such as Acme's warehouse system. The write needs the policy's threshold of valid signatures from the listed keys. With writers: open anyone may write; size and schema still apply.
Names form a tree. Whoever the draft allows creates a top-level namespace, its owners run everything below it, and each topic's policy says who may write: writer keys directly, or users through session keys that a writer delegated.
  • app ledger member
  • key holders
  • registry entry
  • writers
  • topic
WhoWhat they may doHow
The members, by a voteCreate a top-level namespace (create: members). Always available, also to recover a namespace whose owners lost their keystopics init, plan, then topics approve on each node
Registrars, keys named in the draftCreate a top-level namespace alone (create: registrars)topics init, plan, sign, submit
Anyone, first comeClaim an unused single-segment name (create: anyone)the same, signed by the new owners
The owners of a namespace (k-of-n keys)Create entries below it, change policies, rotate owners, retire entries, revoke credentialstopics plan, sign, submit
Writers (k-of-n keys, or anyone when writers: open)Write messages on the topicthe Java or JavaScript client
An issuer: a writer listed under delegateSign short-lived credentials so users write with session keysan application service; topics delegate for tests

Names form a tree:

  • A namespace ends in / and covers every topic below it. The longest matching entry wins: freight/acme/ can override single fields of freight/, and an omitted field inherits. writers: open, an empty delegate list and schema: none are explicit overrides. Retirement is inherited, and a child cannot undo it.
  • A topic no entry covers follows the draft’s unregistered: setting. open, the default of appchain new, accepts it as before. reject refuses it with TOPIC_UNREGISTERED, and the chain then makes blocks only from registered topics. Topics starting with ~ are system topics.
  • Changes take effect later: a committed change activates after the chain’s activation lag (10 blocks by default), never retroactively, so every earlier message stays verifiable under the policy it was written under.

A policy has these fields:

FieldMeaning
writersopen, or threshold of keys: the signatures a write needs
delegateWriter keys that may issue session credentials. Only with a 1-of-n writer set
maxDelegationMsThe longest credential lifetime; the chain’s max-delegation-ms (one hour by default) also caps it
maxPayloadBytesThe largest payload. It applies to open topics too
schemaCddlAn optional CBOR schema for the payload (see below)

Some common policies:

Use caseTopicPolicy
Delivery scans from drivers’ phonesfreight/acme/shipmentswriters 1 of [login service, warehouse system]; the login service in delegate gives drivers one-hour session keys; a schema checks tempC
Payments that need two officersfinance/payments/approvalswriters 2 of [three officers’ keys]; no delegation
Readings from plant gatewaysiot/plant-7/readingswriters 1 of [the gateways’ keys]; maxPayloadBytes 512; a schema
Feedback from any partnerpartners/feedbackwriters: open; size and schema still apply
Scratch or test trafficnot registeredaccepted with unregistered: open, refused with reject
A write on a protected topicIllustrative data

What you're seeing: a driver's app records a delivery scan on freight/acme/shipments with a session key. Step through it, then try a “What if” to see which check stops a bad write.

  1. Log in A driver signs in to Acme's delivery app through the company's SSO; any login the application likes works, including OAuth or a wallet. The app makes a session key pair. The private key is a non-extractable WebCrypto key that never leaves the device.
  2. Issue a credential Acme's login service checks the sign-in and signs a delegation: the session public key, the scope freight/acme/, notBefore and notAfter, bound to this chain and its generation. Its key is a writer of the topic and is listed under delegate.
  3. Write At the customer's dock the app builds a frame for freight/acme/shipments: the payload {shipment: "SHP-1042", tempC: 4} and a proof with a fresh nonce, a notAfter, the credential and the session key's signature over the write statement. The statement binds the chain, generation, topic, payload hash, nonce and expiry. It posts the frame to any member.
  4. Check the policy The member resolves the topic's effective policy from committed state: the longest matching entry, with omitted fields inherited. It then runs the checks in order; the first failure refuses the message with 400 and a code.
    • passes: An entry covers the topic (or unregistered topics are open)
    • passes: The entry is not retired
    • passes: The body is a canonical frame
    • passes: The write proof's notAfter is inside its window
    • passes: The credential: allowed issuer, scope, time, not revoked
    • passes: The session key signed this write
    • passes: This write statement was not used before
    • passes: Payload size and schema
    Effective policy of freight/acme/shipments
    FieldValueFrom entry
    writers1 of [login, warehouse]freight/acme/
    delegate[login]freight/acme/
    maxDelegationMs3,600,000 (1 h)freight/acme/
    maxPayloadBytes4,096freight/ (inherited)
    schematempC: -30..30freight/acme/
    owners2 of [ops, security]freight/acme/
  5. Run the machine Only now do the state machine's own admission and any composite rules run. The machine receives the verified payload as the body; composite rules see writer.kind = delegated, the session key and its issuer. The message id still refers to the submitted frame.
  6. Finalize The proposer and every follower repeat the same checks against the block's parent state. A follower rejects a block that breaks them, which makes the policy a consensus rule. The write statement is recorded as used, and the delivery scan is now evidence every company in the consortium can verify.

What if: A legacy integration posts JSON

An old script posts {"shipment": "SHP-1042"} as the body, with no frame and no signature.

  1. Write The script posts the payload to freight/acme/shipments as an ordinary body, the way it would on an unprotected topic.
  2. Check the policy The topic has writer keys, so the body must be a canonical frame carrying a write proof. It is not.
    • passes: An entry covers the topic (or unregistered topics are open)
    • passes: The entry is not retired
    • fails: The body is a canonical frame TOPIC_FRAME_INVALID
    • not reached: The write proof's notAfter is inside its window
    • not reached: The credential: allowed issuer, scope, time, not revoked
    • not reached: The session key signed this write
    • not reached: This write statement was not used before
    • not reached: Payload size and schema
    Effective policy of freight/acme/shipments
    FieldValueFrom entry
    writers1 of [login, warehouse]freight/acme/
    delegate[login]freight/acme/
    maxDelegationMs3,600,000 (1 h)freight/acme/
    maxPayloadBytes4,096freight/ (inherited)
    schematempC: -30..30freight/acme/
    owners2 of [ops, security]freight/acme/

What if: The credential expired

The app was offline for two hours and queued a scan without refreshing its one-hour credential.

  1. Log in A driver signs in to Acme's delivery app through the company's SSO; any login the application likes works, including OAuth or a wallet. The app makes a session key pair. The private key is a non-extractable WebCrypto key that never leaves the device.
  2. Issue a credential Acme's login service checks the sign-in and signs a delegation: the session public key, the scope freight/acme/, notBefore and notAfter, bound to this chain and its generation. Its key is a writer of the topic and is listed under delegate.
  3. Write Back online, the app signs the queued scan with the old credential. The SDK normally refreshes the credential before it expires; this client did not.
  4. Check the policy The block time is past the credential's notAfter, so the credential no longer stands in for the login service. Get a fresh credential and sign the scan again.
    • passes: An entry covers the topic (or unregistered topics are open)
    • passes: The entry is not retired
    • passes: The body is a canonical frame
    • passes: The write proof's notAfter is inside its window
    • fails: The credential: allowed issuer, scope, time, not revoked TOPIC_DELEGATION_INVALID
    • not reached: The session key signed this write
    • not reached: This write statement was not used before
    • not reached: Payload size and schema
    Effective policy of freight/acme/shipments
    FieldValueFrom entry
    writers1 of [login, warehouse]freight/acme/
    delegate[login]freight/acme/
    maxDelegationMs3,600,000 (1 h)freight/acme/
    maxPayloadBytes4,096freight/ (inherited)
    schematempC: -30..30freight/acme/
    owners2 of [ops, security]freight/acme/

What if: A write for another company

The same session tries to write freight/globex/shipments, a competitor's topic.

  1. Log in A driver signs in to Acme's delivery app through the company's SSO; any login the application likes works, including OAuth or a wallet. The app makes a session key pair. The private key is a non-extractable WebCrypto key that never leaves the device.
  2. Issue a credential Acme's login service checks the sign-in and signs a delegation: the session public key, the scope freight/acme/, notBefore and notAfter, bound to this chain and its generation. Its key is a writer of the topic and is listed under delegate.
  3. Write The app signs a write for freight/globex/shipments with the credential for freight/acme/.
  4. Check the policy The credential's scope, freight/acme/, does not cover the topic. A session key can write only inside the scope it was issued for, so one company cannot write another's records.
    • passes: An entry covers the topic (or unregistered topics are open)
    • passes: The entry is not retired
    • passes: The body is a canonical frame
    • passes: The write proof's notAfter is inside its window
    • fails: The credential: allowed issuer, scope, time, not revoked TOPIC_DELEGATION_INVALID
    • not reached: The session key signed this write
    • not reached: This write statement was not used before
    • not reached: Payload size and schema
    Effective policy of freight/acme/shipments
    FieldValueFrom entry
    writers1 of [login, warehouse]freight/acme/
    delegate[login]freight/acme/
    maxDelegationMs3,600,000 (1 h)freight/acme/
    maxPayloadBytes4,096freight/ (inherited)
    schematempC: -30..30freight/acme/
    owners2 of [ops, security]freight/acme/

What if: The scan is sent twice

A retry on a flaky network, or a proxy, posts the same final frame again.

  1. Log in A driver signs in to Acme's delivery app through the company's SSO; any login the application likes works, including OAuth or a wallet. The app makes a session key pair. The private key is a non-extractable WebCrypto key that never leaves the device.
  2. Issue a credential Acme's login service checks the sign-in and signs a delegation: the session public key, the scope freight/acme/, notBefore and notAfter, bound to this chain and its generation. Its key is a writer of the topic and is listed under delegate.
  3. Write At the customer's dock the app builds a frame for freight/acme/shipments: the payload {shipment: "SHP-1042", tempC: 4} and a proof with a fresh nonce, a notAfter, the credential and the session key's signature over the write statement. The statement binds the chain, generation, topic, payload hash, nonce and expiry. It posts the frame to any member.
  4. Check the policy The member resolves the topic's effective policy from committed state: the longest matching entry, with omitted fields inherited. It then runs the checks in order; the first failure refuses the message with 400 and a code.
    • passes: An entry covers the topic (or unregistered topics are open)
    • passes: The entry is not retired
    • passes: The body is a canonical frame
    • passes: The write proof's notAfter is inside its window
    • passes: The credential: allowed issuer, scope, time, not revoked
    • passes: The session key signed this write
    • passes: This write statement was not used before
    • passes: Payload size and schema
    Effective policy of freight/acme/shipments
    FieldValueFrom entry
    writers1 of [login, warehouse]freight/acme/
    delegate[login]freight/acme/
    maxDelegationMs3,600,000 (1 h)freight/acme/
    maxPayloadBytes4,096freight/ (inherited)
    schematempC: -30..30freight/acme/
    owners2 of [ops, security]freight/acme/
  5. Run the machine Only now do the state machine's own admission and any composite rules run. The machine receives the verified payload as the body; composite rules see writer.kind = delegated, the session key and its issuer. The message id still refers to the submitted frame.
  6. Finalize The proposer and every follower repeat the same checks against the block's parent state. A follower rejects a block that breaks them, which makes the policy a consensus rule. The write statement is recorded as used, and the delivery scan is now evidence every company in the consortium can verify.
  7. Resend Anyone who has the frame can post the same bytes again, to any member.
  8. Check the policy Every signature is still valid, but the write statement is already recorded as used. A copy never counts twice, so a retry cannot record a delivery twice.
    • passes: An entry covers the topic (or unregistered topics are open)
    • passes: The entry is not retired
    • passes: The body is a canonical frame
    • passes: The write proof's notAfter is inside its window
    • passes: The credential: allowed issuer, scope, time, not revoked
    • passes: The session key signed this write
    • fails: This write statement was not used before TOPIC_PROOF_REPLAYED
    • not reached: Payload size and schema
    Effective policy of freight/acme/shipments
    FieldValueFrom entry
    writers1 of [login, warehouse]freight/acme/
    delegate[login]freight/acme/
    maxDelegationMs3,600,000 (1 h)freight/acme/
    maxPayloadBytes4,096freight/ (inherited)
    schematempC: -30..30freight/acme/
    owners2 of [ops, security]freight/acme/

What if: The payload breaks the schema

A faulty app build reports the temperature in Fahrenheit.

  1. Log in A driver signs in to Acme's delivery app through the company's SSO; any login the application likes works, including OAuth or a wallet. The app makes a session key pair. The private key is a non-extractable WebCrypto key that never leaves the device.
  2. Issue a credential Acme's login service checks the sign-in and signs a delegation: the session public key, the scope freight/acme/, notBefore and notAfter, bound to this chain and its generation. Its key is a writer of the topic and is listed under delegate.
  3. Write The app signs a correct frame whose payload is {shipment: "SHP-1042", tempC: 39}.
  4. Check the policy The signatures and credential are fine, but the topic's schema allows tempC only from -30 to 30. Signatures prove who wrote a message, not that its content makes sense; that is the schema's job.
    • passes: An entry covers the topic (or unregistered topics are open)
    • passes: The entry is not retired
    • passes: The body is a canonical frame
    • passes: The write proof's notAfter is inside its window
    • passes: The credential: allowed issuer, scope, time, not revoked
    • passes: The session key signed this write
    • passes: This write statement was not used before
    • fails: Payload size and schema TOPIC_SCHEMA_REJECTED
    Effective policy of freight/acme/shipments
    FieldValueFrom entry
    writers1 of [login, warehouse]freight/acme/
    delegate[login]freight/acme/
    maxDelegationMs3,600,000 (1 h)freight/acme/
    maxPayloadBytes4,096freight/ (inherited)
    schematempC: -30..30freight/acme/
    owners2 of [ops, security]freight/acme/

What if: Nobody registered the topic

A client writes analytics/clicks, which no entry covers, on a chain sealed with unregistered: reject.

  1. Write The client posts a plain body to analytics/clicks.
  2. Check the policy No entry covers the topic and the chain refuses unregistered topics. With unregistered: open, which appchain new writes by default, the message would be accepted as on a chain without topics.
    • fails: An entry covers the topic (or unregistered topics are open) TOPIC_UNREGISTERED
    • not reached: The entry is not retired
    • not reached: The body is a canonical frame
    • not reached: The write proof's notAfter is inside its window
    • not reached: The credential: allowed issuer, scope, time, not revoked
    • not reached: The session key signed this write
    • not reached: This write statement was not used before
    • not reached: Payload size and schema
  • driver's app
  • application service
  • member node
  • state machine
  • refused
  • A direct write carries the policy’s threshold of writer signatures instead of a credential.
  • A credential stands in for one writer. Its issuer must be listed under delegate and belong to a 1-of-n writer set; it cannot satisfy a 2-of-n policy by itself. A change to the allowed issuers takes effect at its activation height.
  • Signatures bind the chain generation, so a credential copied to a fresh chain grants nothing. A write also binds the topic, payload hash, nonce and expiry, and the host rejects reused, revoked, expired or out-of-scope writes.
  • The machine sees the payload, not the frame. Machine hooks receive the verified payload through getBody(), while the message id, receipt and message proof follow the submitted frame. Do not strip a frame from an archived message or make up a replacement id.
CodeThe write was refused because
TOPIC_UNREGISTEREDno entry covers the topic, and the chain rejects unregistered topics
TOPIC_RETIREDthe entry is retired
TOPIC_FRAME_INVALIDthe topic is protected and the body is not a canonical frame
TOPIC_PROOF_EXPIREDthe write proof’s notAfter has passed or is too far ahead
TOPIC_WRITER_DENIEDsignatures are missing, invalid, below the threshold, or not from writer keys
TOPIC_DELEGATION_INVALIDthe credential’s issuer, scope or time window is wrong, or it was revoked
TOPIC_PROOF_REPLAYEDthis write was already used
TOPIC_PAYLOAD_TOO_LARGEthe payload is above maxPayloadBytes
TOPIC_SCHEMA_REJECTEDthe payload is not canonical CBOR or does not match the schema

Registry commands have their own codes: TOPIC_COMMAND_INVALID, _DENIED, _EXPIRED, _STALE, _LIMIT and _SUPERSEDED.

Topic schemas use the same yano-cbor-schema-ir-v1 evaluator as authenticated-map. CDDL is compiled by CddlSchemaCompiler before submission; members only evaluate the committed IR. Put a topic schema on an opaque machine such as ordered-log. Typed kernels such as balances already define their command format and reject a second topic schema. Composite rules can read the verified payload; see admission rules.

You wantCLIREST, below /api/v1/app-chain/chains/{chainId}
The chain’s topic settingstopics init reads themGET /topics/config
One entry and its revisionsGET /topics/entries/{name}
A topic’s effective policy at the tipGET /topics/resolve?topic=
The same for a block, with proofstopics resolve <topic> [--height <n>], verifiedGET /topics/proof?topic=&height=
A schema’s IRGET /topics/schemas/{hash}
The outcome of a registry commandGET /topics/receipts/{messageId}

All of these are reads. In an entry name, encode the trailing slash: /topics/entries/freight%2F. Owners’ commands are submitted as ordinary messages on ~topics/registry; members’ votes go through the privileged POST /admin/topics/governance, which topics approve calls on each operator’s own node. See the REST API.

An entry-state proof establishes one registry record at a root. It does not establish a topic’s effective policy: ancestors, the absence of overrides and the configuration also matter. appchain topics resolve returns a topic-policy-v1 effective-policy bundle for a candidate height, anchored to its parent state’s root. It includes the configuration revision and source entry revisions, including disabled and unregistered outcomes.

Entry-state proofs come from the generic state proof API, not a separate topic-entry-v1 typed endpoint. Studio labels them as entry-only proofs, and its downloaded peer responses are not independent verification. For authorship, appchain topics verify requires the message, frame, generation and complete effective-policy, replay, revocation and schema evidence, plus independently trusted block/root information; the how-to lists the inputs. It refuses entry-only data. A valid signature alone does not establish current authority or finality.

This implementation pins the Yano host at 0.1.0-pre19, API level 13, with its matching ordinary JVM ZIP. Qualify it on a fresh app-chain genesis. Existing retained deployments remain on their exact host, profile and genesis; this change supplies no in-place migration or reset procedure.

The old collection schema vectors keep their IR bytes and results. The merged core evaluator also hardens the work budget by charging bytes examined in literal comparisons. A pathological legacy value can therefore be rejected at that budget boundary; the regression suite records this case. This is an intentional prerelease boundary, not a claim that every historical state can be replayed under the new host. The host also adds a committed clock-skew field to its consensus profile. Keep old stores with the binary that created them.

Next: protect a topic and give users session keys.