Message Bus Artifact Reference

This page lists the message-bus fields a compiled artifact publishes in artifact.messageBus. Message-bus composition is experimental in 0.14.0-beta.1, and these fields can change between releases. For how the bus works and when to use it, see Atomic Calls with the Message Bus.

Protocol limits

Artifact source	Value
ATOMIC_MESSAGE_BUS_MAX_PARTICIPANTS	8
ATOMIC_MESSAGE_BUS_MAX_ROWS	0xffff
MAX_MESSAGE_BUS_BLOB_BYTES	520 bytes
ATOMIC_MESSAGE_BUS_DOMAIN_HEX	4c33425553310000
P2SH_BYTECODE_LIMIT	10_000 bytes

These are admission ceilings. Finalized transaction size and BCH-2026 VM preflight can impose a smaller limit for a resource-heavy graph.

Artifact.messageBus fields

Field	Schema type
version	1
selector	'53434231'
routeInBytecode	boolean
convention	'legacy-unroll' | 'kernel-row-loop'
available	boolean
admittedHandlerIds	readonly string[]
refusedHandlerIds	readonly string[]
admissionSource	'attribution-spans' | 'legacy-eligibility'
minimumRows	number
maximumRows	number
maximumBlobBytes	number
resourceBudgets	MessageBusResourceBudgets
deployability	DeployabilityCertificate
capabilitySchema	KernelCapabilitySchema
tokenContainerCoLayout	TokenContainerCoLayoutProof

available is false when every handler was refused and the published route is a stub that cannot execute. convention is kernel-row-loop on the default kernel convention; legacy-unroll marks the historical route that messageBusKernel: false selects for compatibility tests.

The nested atomicMessageBus record publishes message-envelope placement and participant/row bounds. The verifierProgram record is deployment material for the artifact-specialized self-preserving verifier; it is not an execution controller.

Handlers

handlers lists the contract's externally callable entry points, admitted or not:

Field	Meaning
name, selector, inputs, outputs	The entry point and its ABI
eligible	Whether the route can execute this handler
rejectionReason	Why a handler was refused; a KERNEL_* code on the kernel convention
rejectionCode	The MESSAGE_BUS_* class of that refusal
witnessOrdinal	The handler's index in the route's eligible dispatch set

A refused handler stays callable through its direct entry point. Compose or batch only eligible handlers of an artifact whose available is true.

Per-route ceilings

maximumRows and maximumBlobBytes are the ceilings for this artifact's own route rather than the shared constants above. A kernel row loop publishes the BCH-2026 stack-item ceiling (10,000 bytes) and its one-byte row count (255 rows). A legacy unrolled route keeps the historical 520-byte envelope and eight rows, or two rows for a resource-shaped batch. A route fits the 10,000-byte P2SH limit only when its deployability certificate says it does.

Admission, budgets and certificates

admittedHandlerIds, refusedHandlerIds, and admissionSource are the admission stamp: which handlers analysis admitted and how the decision was produced, independent of the published handlers[].eligible flags. admissionSource is attribution-spans on the kernel path and legacy-eligibility on the legacy path; a kernel artifact whose admission analysis is missing fails closed instead of falling back.

resourceBudgets publishes multi-axis worst-case budgets (rows, participants, blob bytes, dynamic chunks, value-continuation chunks, journal records, events, transfers, return carriers, external edges, and maximumSemanticDerivationPasses). messageBus.compose() prefers these over SDK constants and fails closed on the kernel path when the field is absent.

deployability is a concrete certificate: status is asserted when measuredBytecodeBytes fits P2SH_BYTECODE_LIMIT and over-budget when it does not, alongside the measured size, the limit, and the mirrored budgets. Absence means a legacy artifact that carries no certificate. assertDeployabilityCertificate() from @solidcash/utils fails closed for both an over-budget and a missing certificate.

capabilitySchema stamps one concrete status per optional capability (asserted, legacy, unsupported, inactive, incomplete) so consumers never read undefined as an implicit meaning. Resolve entries with resolveKernelCapability() and assertKernelCapabilityStatus() from @solidcash/utils rather than testing the optional fields directly.

kernelExecutionPlans commits one digest per admitted handler into the route bytecode; each digest appears as a unique push/drop marker in artifact.bytecode. Readers gate on kernelPlanVersion through assertReadableKernelExecutionPlans() from solidcash/message-bus.

tokenContainerCoLayout is a non-overlapping span proof for a route that reserves token-container slots beside trailing dynamic-value capacity.