Reference: SDK API (every export)

Generated for @chainrender/client 0.21.0 — these are its exports, exactly. Using another version? Check yours with npm ls @chainrender/client.

Every export of @chainrender/client, generated from the SDK source: the signature as written and the doc comment next to it. If a name is not on this page, the package does not export it — do not import it. Import paths are exact: an export listed under @chainrender/client is not available from @chainrender/client/runtime, and a name listed inside a namespace (for example events.eventTopic0) is reached through that namespace (import { events } from "@chainrender/client/runtime").

For what each part is for and how to combine them, start with @chainrender/client, Runtime API and React API. viem is a required peer dependency.

Coverage: 180 value exports across 4 entry points; 171 carry a doc comment in the source. Without one (signature only): compile, decompile, DecompileError, HINTS, HINTS_REGISTRY_VERSION, hintSpec, hintRegistry, presentationFindings, isCrArg.

@chainrender/client

Authoring core: compile, check, grade, describe, validate, the vocabulary, manifests, themes, naming.

import { compileComponent } from "@chainrender/client";

Compile

compileComponent

function compileComponent(root: Node, opts: CompileOptions = {}): Compiled

Compiles a JSON AST component and returns its bytes, hex, content hash, and size.

Source: chainc/index.ts

compileJsx

function compileJsx(src: string): Compiled

Compiles a JSX-like string via the thin front-end, then the shared JSON-AST core.

Source: chainc/index.ts

compile

function compile(root: Node, opts: CompileOptions = {}): Uint8Array

No doc comment in the source.

Source: chainc/compile.ts

parseJsx

function parseJsx(src: string): Node

Parses a JSX-like string into the chainc JSON AST.

Source: chainc/jsx.ts

toHex

function toHex(bytes: Uint8Array): `0x${string}`

Hex-encodes CRO2 bytes as an 0x-prefixed string (for passing to viem/ethers).

Source: chainc/compile.ts

Decompile (0.21.0): CRO2 bytes back to the tree, exact or it throws — the builder's Fork (doc 119 §3.6)

decompile

function decompile(input: Uint8Array | string): Decompiled

No doc comment in the source.

Source: chainc/decompile.ts

DecompileError

class DecompileError extends Error

No doc comment in the source.

Source: chainc/decompile.ts

Vocabulary constants + IR builders (the closed vocabularies)

format (namespace)

chainc — CRO2 format constants.

Source: chainc/format.ts

compose (namespace)

@chainrender/client — compose.*: ergonomic, typed AST builders (doc 73 §4). Thin constructors over the Node union plus re-exported IR builder modules, so a builder / AI / MCP constructs valid trees without hand-writing object literals. Everything here returns plain Nodes in the closed vocabulary — nothing here can express outside it (constrained by construction).

Source: client/compose.ts

Introspect

requiredCapabilities

function requiredCapabilities(node: Node): number

Derive the capability bits the behaviour REQUIRES from what the AST actually contains. This is the honest capability set: declaring more is over-claiming, declaring less is under-declaring.

Source: chainc/describe.ts

describeBehavior

function describeBehavior(node: Node, declaredCaps: number): BehaviorDescriptor

What a component can do, in plain language, derived from its AST without running it: the capabilities it requires vs the ones declared (and whether that declaration is honest), its actions, batches, signature requests, chain reads, media, GPU use and off-chain fetches, plus a human-readable summary. Pass requiredCapabilities(node) as declaredCaps to describe the honest set.

Source: chainc/describe.ts

describeComposition

function describeComposition(manifest: { scene: { kind: number; gpu?: boolean }; components: { hash: string; anchor: number; capabilities: number }[]; aggregated?: number; capabilities?: number; }, componentFloors: Map<string, BehaviorDescriptor>, anchorName: (a: number) => string,): CompositionFloor

The composed floor of a mini-app: the scene, every placed component with what each can do, and the aggregated capability set with whether it is escalation-free (the aggregate equals the union of the components' caps).

Source: chainc/describe.ts

Validate

collectBehavior

function collectBehavior(node: Node): Collected

One walk of the AST collecting everything with consequences: actions, resolvers, refs, media, batches and signature requests. The same walk validateApp() and describeBehavior() use, so the description and the checks cannot disagree.

Source: chainc/validate.ts

validateApp

function validateApp(manifest: AppManifestInput, rootAst: Node, knownComponents: Set<string>, knownApps?: Set<string>,): ValidationReport

Validates an assembled app.

Source: chainc/validate.ts

validateComposition

function validateComposition(manifest: { scene: { kind: number; ref: string; gpu?: boolean }; components: { hash: string; anchor: number; capabilities: number }[]; capabilities?: number; aggregated?: number; parent?: string; }, knownComponentCaps: Map<string, number>, knownCompositions?: Set<string>,): ValidationReport

Validate a composition (mini-app): a scene + placed components + aggregated capabilities. The heart is capability aggregation with NO privilege escalation — the mini-app's capability set must be EXACTLY the union of its components' own declared capabilities (plus the scene's GPU), and no placed component may claim a capability it doesn't actually have. Placement aggregates and surfaces power; it never grants it.

Source: chainc/validate.ts

Enforce (the drift-guarded mirrors of the on-chain enforcer)

analyze

function analyze(parts: Part[]): Analysis

The grade computation without the refusal rails: the capability envelope (union of every part's caps), the worst-link grade across the presentation, data and dependency axes, and one deviation per axis below A. Mirrors contracts/enforcer/TrustGrade.sol; most callers want check() or grade().

Source: chainc/trustgrade.ts

check

function check(parts: Part[], declaredEnvelope?: number): Result

The enforcer gate: rails first (R1 escape-hatch, I5 malformed, R2 capability-dishonesty), then grade.

Source: chainc/trustgrade.ts

gateAction

function gateAction(a: Action, envelope: number, allowed: Target[]): number

The action gate (doc 67 §4b): permit an action only if it fits the effective envelope + declared call set.

Source: chainc/trustgrade.ts

gateBinding

function gateBinding(bindCap: number, envelope: number): number

Rule R6: a data binding may not need a capability outside the envelope. Returns GATE.OK or GATE.OFF_ENVELOPE_BIND.

Source: chainc/trustgrade.ts

firstBlocked

function firstBlocked(actions: Action[], envelope: number, allowed: Target[]):

Runs gateAction() over a list and returns the first action it refuses (index and GATE reason), or blocked: false.

Source: chainc/trustgrade.ts

gradeLetter

function gradeLetter(g: number): string

presentation-layer helpers (the label)

Source: chainc/trustgrade.ts

gradeWord

function gradeWord(g: number): string

The word for a grade number: A "Trustless", B "Pinned", C "Live", X "Refused".

Source: chainc/trustgrade.ts

gradeLocks

function gradeLocks(g: number): string

The padlock meter for a grade number: A 🔒🔒🔒, B 🔒🔒◻, C 🔒◻◻, X ⛔.

Source: chainc/trustgrade.ts

CAP

const CAP = { … } as const

capability bits — MUST match chainc/manifest.ts CAP and TrustGrade.sol

Source: chainc/trustgrade.ts

GRADE

const GRADE = { … } as const

Grade numbers: A = 3 (Trustless), B = 2 (Pinned), C = 1 (Live), X = 0 (Refused). Higher is more trustless.

Source: chainc/trustgrade.ts

GATE

const GATE = { … } as const

Action-gate results: OK, or why an action is refused — a capability outside the envelope (R3), value without TRANSFER_VALUE (R4), a target not in the declared call set (R5), a binding outside the envelope (R6).

Source: chainc/trustgrade.ts

PRES

const PRES = { … } as const

Presentation axis: COMPUTED (rendered from on-chain interpreter output) grades A, PINNED B, LIVE C.

Source: chainc/trustgrade.ts

DEP

const DEP = { … } as const

Dependency axis: NONE / IMMUTABLE grade A, ATTESTED (content-addressed, pinned on-chain) B, UNPROVEN / MUTABLE C.

Source: chainc/trustgrade.ts

construct

function construct(a: WriteAction, userArgs: string[], envelope: number, allowed: Target[]): Constructed

Gate-check then construct the tx for signing. Returns ok=false + reason if the gate blocks it (no tx).

Source: chainc/actionvocab.ts

word

function word(n: bigint): string

Encode a bigint as a left-padded 32-byte word (for uint256 / bool user args).

Source: chainc/actionvocab.ts

addrWord

function addrWord(addr: string): string

Encode an address as a left-padded 32-byte word.

Source: chainc/actionvocab.ts

userArgCount

function userArgCount(a: WriteAction): number

How many of an action's argument slots the user fills in (source ARG.USER), as opposed to fixed by the component.

Source: chainc/actionvocab.ts

ARG

const ARG = { … } as const

Where an action argument comes from: FIXED in the component, or USER-supplied at the wallet.

Source: chainc/actionvocab.ts

ATYPE

const ATYPE = { … } as const

The argument types the closed action vocabulary can encode.

Source: chainc/actionvocab.ts

Manifest / addressing

buildManifest

function buildManifest(input: AppManifestInput): BuiltManifest

Builds the canonical manifest bytes and app hash.

Source: chainc/manifest.ts

capabilityNames

function capabilityNames(bitmap: number): string[]

Human-readable capability names for a declared envelope, for consent/display surfaces.

Source: chainc/manifest.ts

NET-NEW core primitives (doc 73 §8)

grade

function grade(node: Node, opts: GradeOptions = {}): GradeResult

Live, no-deploy trust grade of a component AST. Derives caps via requiredCapabilities, then grades as the chain does. Grade (presentation/data/dependency) and envelope (what it can touch) are orthogonal — both are returned; a WRITE component is still Grade A if it renders from computed, immutable, on-chain material.

Source: client/grade.ts

gradeCaps

function gradeCaps(caps: number, opts: GradeOptions = {}): GradeResult

Grade a capability set directly — the single source of truth grade() and gradeComposition() both call. Mirrors the seed's per-item derivation exactly, so it is drift-locked to the on-chain enforcer.

Source: client/grade.ts

gradeComposition

function gradeComposition(aggregatedCaps: number, opts: GradeOptions = {}): GradeResult

Grade a composition / app from its aggregated capability union (the honest aggregate the validator enforces — pass the composition's aggregated caps here).

Source: client/grade.ts

aboveFloorText

function aboveFloorText(kinds: readonly string[]): string

What runs above the floor, in words: "a client-side p5 sketch", "client-side reads of the viewer's own wallet and a client-side transfer history read from logs" (docs/201). The review and the builder say it the same way.

Source: client/grade.ts

isVerifiablePinnedDep

function isVerifiablePinnedDep(pd?: PinnedDep | null): boolean

Pinned-IPFS dependency → Grade B (Pinned): the drift-guarded predicate + type an app/builder/AI uses to declare an honest off-chain-but-content-addressed dependency (docs/B-GRADE-pinned-ipfs-dependency.md).

Source: chainc/pinneddep.ts

pinnedDependencyLevel

function pinnedDependencyLevel(pd?: PinnedDep | null): number | null

The dependency level a pinned dep contributes: DEP.ATTESTED (→ B) when honest, else null (leave the caller's default, i.e. IMMUTABLE → A). Fail-closed: an invalid CID never yields a silent B.

Source: chainc/pinneddep.ts

pinnedCid

function pinnedCid(pd?: PinnedDep | null): string

Pinned-IPFS dependency → Grade B (Pinned): the drift-guarded predicate + type an app/builder/AI uses to declare an honest off-chain-but-content-addressed dependency (docs/B-GRADE-pinned-ipfs-dependency.md).

Source: chainc/pinneddep.ts

RAW_CIDV1

const RAW_CIDV1 = /^bafkrei[a-z2-7]{52}$/

The ONLY re-verifiable shape: a raw CIDv1 (bafkrei…). dag-pb (Qm… / bafybe…) can't be verified in-browser.

Source: chainc/pinneddep.ts

vocabulary

function vocabulary(opts: { mode?: VocabMode } = {}): VocabularySchema

The machine-readable vocabulary. Constrains AI generation to valid IR and generates MCP tool surfaces. { mode: "enhanced" } (docs/202 §16.4) adds the VERSION_5 presentation fields; the default "classic" is exactly the pre-V5 vocabulary, so an AI or tool in classic mode can never emit a tree a chain without V5 refuses.

Source: client/vocabulary.ts

v0.10.0: the strict schema of compile()'s input (chainc/node-schema.ts)

checkNode

function checkNode(root: unknown, opts: { authoring?: boolean; mode?: "classic" | "enhanced" } = {}): NodeCheck

Check a tree against the strict schema plus the limits compile() / the interpreter enforce. Never throws. { authoring: true } accepts the builder-only AUTHORING_FIELDS (slot/image argValues, image.scene, a root pinnedDep, and _-prefixed design-time keys) without an issue.

Source: chainc/node-schema.ts

nodeJsonSchema

function nodeJsonSchema(opts: { authoring?: boolean } = {}): JsonSchema

The strict JSON Schema (draft 2020-12) of the tree compile() consumes. The node def is recursive. Limits that JSON Schema cannot express (total nodes, depth, encoded byte lengths, pinnedDep only at the root) are enforced by checkNode(). { authoring: true } also admits the builder-only AUTHORING_FIELDS.

Source: chainc/node-schema.ts

fieldsOf

function fieldsOf(type: NodeType): FieldSpec[]

Every field compile() reads for a node type, in emit order (type fields, then a11y, then behaviour, then the VERSION_5 presentation fields).

Source: chainc/node-schema.ts

NODE_TYPES

const NODE_TYPES = [ … ] as const

Element types (everything but ref).

Source: chainc/node-schema.ts

NODE_ENUMS

const NODE_ENUMS = { … } as const

compile() silently drops what it does not read (unknown fields, bad enum values, a11y on images, batch args); checkNode() reports each with its path, and nodeJsonSchema() is the same rules as a JSON Schema an AI tool or MCP server hands to a model. Drift-locked to compile() by tsc (_coverage) and by test/node-schema.ts.

Source: chainc/node-schema.ts

TYPE_FIELDS

const TYPE_FIELDS: Record<NodeType, FieldSpec[]> = { … }

Type-specific fields, in compile()'s emit order.

Source: chainc/node-schema.ts

A11Y_FIELDS

const A11Y_FIELDS: FieldSpec[] = [ … ]

Accessibility fields: every element type except image (which uses alt) and ref.

Source: chainc/node-schema.ts

BEHAVIOR_FIELDS

const BEHAVIOR_FIELDS: FieldSpec[] = [ … ]

Behaviour fields: every element type except ref (images included).

Source: chainc/node-schema.ts

AUTHORING_FIELDS

const AUTHORING_FIELDS = { … } as const

Authoring fields: read by the visual builder / grade(), never by compile(). A builder tree may carry them; a tree handed to compile() should not (the builder's encodeBindings() turns them into compiled fields or drops them). checkNode reports them as authoring-field unless called with { authoring: true }; with it, image.scene is checked against SCENE_FIELDS and SCENE_BINDS (0.11.0), while argValues / pinnedDep contents stay the builder's to validate. Grounded in builder/index-next.html: - slot/image argValues the human-typed resolver args, keyed by arg name; encodeBindings() encodes them into arg per the kind's descriptor (abi.encode, or packed when argsEncoding says so) - image.scene the client-side sketch that runs ABOVE the on-chain floor (builder "Scene" panel) - root pinnedDep the pinned-dependency declaration grade() reads (grade(tree, { pinnedDep: tree.pinnedDep })) - any _-prefixed key design-time metadata (_multiview, _view, _mvId for multi-view tabs) 0.10.0 listed only image.scene and root pinnedDep, so a builder tree with argValues was wrongly flagged.

Source: chainc/node-schema.ts

AUTHORING_PREFIX

const AUTHORING_PREFIX = "_"

Keys starting with this prefix are builder design-time metadata on any element (see AUTHORING_FIELDS).

Source: chainc/node-schema.ts

SCENE_FIELDS

const SCENE_FIELDS: FieldSpec[] = [ … ]

The fields of image.scene, exactly as the builder's Scene panel and rich-media deploy read them (builder/index-next.html). An empty string means "not set" for seed / libHash / entry, as in the builder's inputs. At deploy the builder stores source in SourceStore (chunked if large) and registers the scene in SceneComponentRegistry with the binding (libHash, seed, SourceStore id[, app metadata]) — see chainc/depscene.ts.

Source: chainc/node-schema.ts

SCENE_BINDS

const SCENE_BINDS = [ … ] as const

The bind values that make an image's scene a rich-media sketch. The builder only treats image.scene as a sketch when the image's bind is one of these (builder/index-next.html: findScene / runAboveFloorPreview / the rich-media deploy all test bind === "p5" || bind === "three").

Source: chainc/node-schema.ts

IGNORED_BY_COMPILE

const IGNORED_BY_COMPILE: Partial<Record<NodeType, string[]>> = { … }

Fields the TypeScript Node type allows but compile() never encodes. The checker reports them; the runtime drift test proves compile() really ignores them (setting one leaves the bytes unchanged).

Source: chainc/node-schema.ts

IGNORED_NESTED

const IGNORED_NESTED: Record<string, string[]> = { … }

Nested fields the type allows but compile() drops: a batch member's args is not part of the encoded to|sig|value|label member, so it never reaches the wallet.

Source: chainc/node-schema.ts

NODE_LIMITS

const LIMITS = { … } as const  (exported as NODE_LIMITS)

compile() silently drops what it does not read (unknown fields, bad enum values, a11y on images, batch args); checkNode() reports each with its path, and nodeJsonSchema() is the same rules as a JSON Schema an AI tool or MCP server hands to a model. Drift-locked to compile() by tsc (_coverage) and by test/node-schema.ts.

Source: chainc/node-schema.ts

v0.16.0: one review for every surface (client/review.ts, docs/190)

reviewTree

function reviewTree(tree: unknown, opts: ReviewOptions = {}): Review

Review a tree: check + grade + compile + honesty, and the pass/fail verdict every surface reports.

Source: client/review.ts

reviewText

function reviewText(r: Review, title = "ChainRender review"): string

The review as plain text — what the builder's "Copy for AI" button and the command line print. An AI that cannot run the review itself is given this text, and fixes what it lists.

Source: client/review.ts

v0.14.0: honesty and privacy findings (chainc/honesty.ts, docs/188)

honestyFindings

function honestyFindings(root: unknown, opts: HonestyOptions = {}): HonestyFinding[]

Honesty and privacy findings for a Node tree. Empty array = nothing to fix.

Source: chainc/honesty.ts

publicInputNames

function publicInputNames(args: string | readonly string[] | undefined | null): string[]

The $name placeholders in an action's args — a comma-separated template ("$amount,0xabc…") or a list.

Source: chainc/honesty.ts

publicInputNotice

function publicInputNotice(names: readonly string[]): string

The sign-panel line for an action whose args take these input names; "" when it takes none.

Source: chainc/honesty.ts

PUBLIC_INPUT_NOTICE

const PUBLIC_INPUT_NOTICE = "Values you enter here become public on-chain, permanently: anyone can read them."

The line every surface that signs an action with typed-in values shows (viewer sign panel, apps, AI-built UIs).

Source: chainc/honesty.ts

ONCHAIN_P5_VERSION

const ONCHAIN_P5_VERSION = "2.3.2"

The p5 every ChainRender chain registers in its DependencyRegistry (deployment/genesis-libraries*.json: p5@2.3.2 is the only p5 on Sepolia, Robinhood and Arc).

Source: chainc/honesty.ts

p5V1ApiUses

function p5V1ApiUses(source: string):

Where a p5 sketch uses the p5 1.x API the on-chain p5 2.3.2 does not have. Each item: what, the line (1-based, in the sketch source) of its first use, how many uses, and the 2.x replacement. Empty = none found.

Source: chainc/honesty.ts

signMessageProblems

function signMessageProblems(sign: AnyNode): string[]

What is wrong with an EIP-712 sign object's message: a $name (never substituted), or a value that does not fit its declared type (address, bool, uintN/intN, bytesN, string; nested struct types are followed). Empty = fine.

Source: chainc/honesty.ts

v0.20.0: VERSION_5 presentation — style tokens, hints, lang/dir, heading levels, WAI-ARIA roles (docs/202)

STYLE_FAMILIES

const STYLE_FAMILIES: readonly StyleFamily[] = [ … ] as const

Enhanced mode only: compile(tree, { mode: "enhanced" }) / compileComponent(tree, { mode: "enhanced" }) / checkNode(tree, { mode: "enhanced" }) / reviewTree(tree, { mode: "enhanced" }) / vocabulary({ mode: "enhanced" }). The default (classic) is exactly the pre-V5 behaviour. VERSION_5 renders only where the chain's RenderRouter.interpreterFor(5) is the V5 HTML interpreter (doc 202 phase 2).

Source: chainc/style-tokens.ts

STYLE_TOKENS

const STYLE_TOKENS: ReadonlyMap<string, StyleFamily> = new Map(STYLE_FAMILIES.flatMap((f) => f.values.map((v) => [f.token(v), f] as const)))

Every registered token, by token string -> its family.

Source: chainc/style-tokens.ts

STYLE_TOKEN_RE

const STYLE_TOKEN_RE = /^[a-z][a-z0-9]{0,15}(-[a-z0-9]{1,15}){0,3}$/

One wire token: a lowercase word, then up to three -segments. docs/202 §4.1 (the V5 interpreter enforces the same).

Source: chainc/style-tokens.ts

STYLE_REGISTRY_VERSION

const STYLE_REGISTRY_VERSION = 1

Enhanced mode only: compile(tree, { mode: "enhanced" }) / compileComponent(tree, { mode: "enhanced" }) / checkNode(tree, { mode: "enhanced" }) / reviewTree(tree, { mode: "enhanced" }) / vocabulary({ mode: "enhanced" }). The default (classic) is exactly the pre-V5 behaviour. VERSION_5 renders only where the chain's RenderRouter.interpreterFor(5) is the V5 HTML interpreter (doc 202 phase 2).

Source: chainc/style-tokens.ts

styleFamily

const styleFamily = (name: string): StyleFamily | undefined => …

Enhanced mode only: compile(tree, { mode: "enhanced" }) / compileComponent(tree, { mode: "enhanced" }) / checkNode(tree, { mode: "enhanced" }) / reviewTree(tree, { mode: "enhanced" }) / vocabulary({ mode: "enhanced" }). The default (classic) is exactly the pre-V5 behaviour. VERSION_5 renders only where the chain's RenderRouter.interpreterFor(5) is the V5 HTML interpreter (doc 202 phase 2).

Source: chainc/style-tokens.ts

styleFamiliesFor

const styleFamiliesFor = (type: NodeType): StyleFamily[] => …

Enhanced mode only: compile(tree, { mode: "enhanced" }) / compileComponent(tree, { mode: "enhanced" }) / checkNode(tree, { mode: "enhanced" }) / reviewTree(tree, { mode: "enhanced" }) / vocabulary({ mode: "enhanced" }). The default (classic) is exactly the pre-V5 behaviour. VERSION_5 renders only where the chain's RenderRouter.interpreterFor(5) is the V5 HTML interpreter (doc 202 phase 2).

Source: chainc/style-tokens.ts

styleStringOf

function styleStringOf(node: { type: string } & Record<string, unknown>): string | undefined

The ATTR.STYLE string for a node: its family fields in registry order, then raw style tokens (sorted, de-duplicated, grammar-valid only). Deterministic, so the same tree always gives the same hash. Families not allowed on the node's type and values not in the family are left out (checkNode reports them). Returns undefined when there are none.

Source: chainc/style-tokens.ts

isValidStyleList

function isValidStyleList(s: string): boolean

Whether a wire style list passes the V5 grammar (what the interpreter checks; anything else is dropped whole).

Source: chainc/style-tokens.ts

structureCss

function structureCss(opts: { scope?: string } = {}): string

The structure CSS: one rule per token, the heading levels, the app container. Only elements carrying cr-t or aria-level (VERSION_5 output) match, so it has no effect on V2–V4 apps. scope is the app root's selector.

Source: chainc/style-tokens.ts

structureCssProblems

function structureCssProblems(css: string): string[]

What the honesty rules (docs/202 §11) forbid in the structure CSS. Empty = fine. Exceptions are by name: overflow only in the scroll family, content only as "" (marker shapes), a literal colour only as a var() fallback, font sizes only as max(12px, calc(var(--cr-…) * k)) with k >= FONT_FLOOR.

Source: chainc/style-tokens.ts

STRUCTURE_SCOPE

const STRUCTURE_SCOPE = ".cr-root"

The default app root the structure CSS is scoped to (the SDK themes and the builder preview use .cr-root).

Source: chainc/style-tokens.ts

styleRegistry

function styleRegistry()

For vocabulary({ mode: "enhanced" }) and the docs.

Source: chainc/style-tokens.ts

HINTS

const HINTS: readonly HintSpec[] = [ … ]

No doc comment in the source.

Source: chainc/hints.ts

HINTS_REGISTRY_VERSION

const HINTS_REGISTRY_VERSION = 1

No doc comment in the source.

Source: chainc/hints.ts

hintSpec

const hintSpec = (key: string): HintSpec | undefined => …

No doc comment in the source.

Source: chainc/hints.ts

hintStringOf

function hintStringOf(hints: unknown): string | undefined

The ATTR.HINTS string for a node's hints object: known keys in registry order, then other grammar-valid keys sorted. Pairs whose key or value break the grammar are left out (checkNode reports them). Undefined when there are none.

Source: chainc/hints.ts

hintProblems

function hintProblems(type: NodeType, hints: unknown): string[]

Problems with a node's hints (empty = fine): grammar, unknown keys, wrong node type, values that do not fit.

Source: chainc/hints.ts

hintRegistry

function hintRegistry()

No doc comment in the source.

Source: chainc/hints.ts

presentationFieldsOf

function presentationFieldsOf(type: NodeType): FieldSpec[]

VERSION_5 presentation fields for a node type (docs/202), in compile()'s emit order: the style families its type allows (chainc/style-tokens.ts), raw style, hints, lang, dir, and level (not on images). Each opts the component into VERSION_5.

Source: chainc/node-schema.ts

PRESENTATION_KEYS

const PRESENTATION_KEYS = [ … ] as const

Runtime half (test/style-tokens.ts): equals the registry's families + style/hints/lang/dir/level.

Source: chainc/node-schema.ts

presentationFindings

function presentationFindings(tree: unknown, opts: PresentationReviewOptions = {}): PresentationFinding[]

No doc comment in the source.

Source: client/presentation-review.ts

PRESENTATION_RULES

const PRESENTATION_RULES: readonly { rule: PresentationRule; severity: "warn" | "error"; when: string }[] = [ … ]

For the docs and the builder: the rules and what each checks.

Source: client/presentation-review.ts

THEME_LABEL_HOOKS

const THEME_LABEL_HOOKS: readonly string[] = [ … ]

The aria-label values the default theme styles by (a frozen list for existing hashes, docs/202 §1.2, §12) that read as machine names: lowercase ("dash-row", "alert-*", "tooltip"). The capitalised ones the theme also matches ("Addresses", "Ownership", "Records") are real names a person would give the element, so they are not flagged.

Source: client/presentation-review.ts

v0.19.0: the viewer's own wallet data and transfer histories (chainc/viewer-context.ts, docs/201)

VIEWER_PLACEHOLDER

const VIEWER_PLACEHOLDER = "$viewer"

The placeholder an author writes for the viewer's own address.

Source: chainc/viewer-context.ts

VIEWER_KINDS

const VIEWER_KINDS: readonly ViewerKind[] = [ … ]

A viewer read is a client slot whose account arg is "$viewer"; a transfer history is a client slot bound to "transfers". The on-chain render shows their fallback text to everyone; a ChainRender viewer fills them only after the person chooses to show their own data, with this chain's published resolvers (⚙ above the floor).

Source: chainc/viewer-context.ts

VIEWER_READS

const VIEWER_READS = { … } as const

For vocabulary(): what an author (or an AI) needs to write one.

Source: chainc/viewer-context.ts

VIEWER_FALLBACK

const VIEWER_FALLBACK = "Connect your wallet to see this"

What a viewer slot shows until the person chooses to show their data (the builder uses it when content is empty).

Source: chainc/viewer-context.ts

HISTORY_BIND

const HISTORY_BIND = "transfers"

The bind of a transfer-history slot.

Source: chainc/viewer-context.ts

HISTORY_KINDS

const HISTORY_KINDS = [ … ] as const

ChainRenderFeed kinds a history may read (no raw logs, and no chain-wide transfers mix).

Source: chainc/viewer-context.ts

HISTORY_LIMITS

const HISTORY_LIMITS = { … } as const

A viewer read is a client slot whose account arg is "$viewer"; a transfer history is a client slot bound to "transfers". The on-chain render shows their fallback text to everyone; a ChainRender viewer fills them only after the person chooses to show their own data, with this chain's published resolvers (⚙ above the floor).

Source: chainc/viewer-context.ts

HISTORY_FALLBACK

const HISTORY_FALLBACK = "Recent transfers load in a ChainRender viewer"

A viewer read is a client slot whose account arg is "$viewer"; a transfer history is a client slot bound to "transfers". The on-chain render shows their fallback text to everyone; a ChainRender viewer fills them only after the person chooses to show their own data, with this chain's published resolvers (⚙ above the floor).

Source: chainc/viewer-context.ts

VIEWER_HISTORY_FALLBACK

const VIEWER_HISTORY_FALLBACK = "Connect your wallet to see your recent transfers"

A viewer read is a client slot whose account arg is "$viewer"; a transfer history is a client slot bound to "transfers". The on-chain render shows their fallback text to everyone; a ChainRender viewer fills them only after the person chooses to show their own data, with this chain's published resolvers (⚙ above the floor).

Source: chainc/viewer-context.ts

SAMPLE_ACCOUNT

const SAMPLE_ACCOUNT = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"

The address the builder previews viewer slots with when no wallet is connected — labelled a sample everywhere.

Source: chainc/viewer-context.ts

viewerFallback

function viewerFallback(node: unknown): string | null

The fallback text (the floor) a viewer slot shows to everyone until the viewer fills it.

Source: chainc/viewer-context.ts

viewerKind

const viewerKind = (kind: unknown): ViewerKind | undefined => …

A viewer read is a client slot whose account arg is "$viewer"; a transfer history is a client slot bound to "transfers". The on-chain render shows their fallback text to everyone; a ChainRender viewer fills them only after the person chooses to show their own data, with this chain's published resolvers (⚙ above the floor).

Source: chainc/viewer-context.ts

viewerReadArg

function viewerReadArg(kind: string, values: Record<string, unknown>): string

The client-slot arg for a viewer read: cr:viewer;token=0x…;account=$viewer. Throws on anything the viewer would refuse.

Source: chainc/viewer-context.ts

historyArg

function historyArg(values: Record<string, unknown>): string

The client-slot arg for a transfer history: cr:history;kind=token-transfers;account=$viewer;token=0x…;blocks=5000;limit=20.

Source: chainc/viewer-context.ts

parseCrArg

function parseCrArg(text: unknown): CrArg

Parses a cr: arg. Strict: one mode, known keys, no repeats, bounded. Does not check the fields against a kind.

Source: chainc/viewer-context.ts

viewerReadProblems

function viewerReadProblems(kind: unknown, fields: Record<string, unknown>): string[]

Problems with a viewer read for kind given its fields (empty = fine).

Source: chainc/viewer-context.ts

historyProblems

function historyProblems(fields: Record<string, unknown>): string[]

Problems with a transfer history's fields (empty = fine).

Source: chainc/viewer-context.ts

viewerNodeMode

function viewerNodeMode(node: unknown): "viewer" | "history" | null

Whether argValues (or an already-encoded arg) make this node a viewer read or a transfer history.

Source: chainc/viewer-context.ts

v0.11.0: presentation context (render-time theme / palette / size, doc 106)

presentationContext

function presentationContext(o: { themeId?: `0x${string}`; palette?: ContextPalette; // chart/image palette override tokens?: ThemeTokens; // OR derive the palette from a full token set chartW?: number; chartH?: number; overrideTokens?: ThemeTokens; // doc 109: full token override (regenerates component CSS at render time) ext?: `0x${string}`; }): PresentationContext

Build a present context from optional overrides — the viewer's ergonomic entry (theme/palette/dims).

Source: chainc/presentation-context.ts

emptyContext

function emptyContext(): PresentationContext

The empty context — everything falls back to the component's baked defaults (== renderHash behavior).

Source: chainc/presentation-context.ts

PRESENTATION_CONTEXT_ABI

const PRESENTATION_CONTEXT_ABI = { … } as const

The ABI tuple for PresentationContextLib.Context — field order MUST match the Solidity struct exactly.

Source: chainc/presentation-context.ts

PRESENTATION_CONTEXT_VERSION

const PRESENTATION_CONTEXT_VERSION = 1

Build the context renderComponentWithContext() (@chainrender/client/runtime) passes to RenderRouter.renderHashWithContext. Skin only: never identity, behaviour or grade.

Source: chainc/presentation-context.ts

v0.11.0: rich-media scene binding (chainc/depscene.ts)

encodeSceneBinding

function encodeSceneBinding(b: SceneBinding): `0x${string}`

abi-encode a binding: 3 fields, or 4 when meta is a non-empty string (the builder's rich-media deploy form).

Source: chainc/depscene.ts

decodeSceneBinding

function decodeSceneBinding(kind: SceneKind, value: `0x${string}`): SceneBinding

Decode either form; meta is present only for a 4-field binding.

Source: chainc/depscene.ts

sceneIdOf

function sceneIdOf(floorContract: `0x${string}`, floorSelector: `0x${string}`, seed: `0x${string}`, binding: `0x${string}`): `0x${string}`

SceneComponentRegistry.idOf: keccak256(abi.encode(floorContract, floorSelector, seed, binding)).

Source: chainc/depscene.ts

sceneNamespaceId

const namespaceId = (kind: SceneKind): `0x${string}` => …  (exported as sceneNamespaceId)

namespace id the ComponentAnnotationRegistry keys on (keccak of the namespace string)

Source: chainc/depscene.ts

SCENE_NS

const SCENE_NS = { … } as const

The binding a p5/three app carries: the on-chain library by DependencyRegistry hash, the seed, and the sketch (a SourceStore id once deployed), optionally with app metadata — exactly what the builder's rich-media deploy registers in SceneComponentRegistry. Previously documented but not exported.

Source: chainc/depscene.ts

SCENE_FLOOR_SELECTORS

const SCENE_FLOOR_SELECTORS = { … } as const

The on-chain floors SceneFloor ships (contracts/SceneFloor.sol), by name → 4-byte selector. A registered scene's floor is floorContract.<selector>(seed); the builder's rich-media deploy uses sigil.

Source: chainc/depscene.ts

First-party on-chain resolver kinds (oracle feeds, selective-disclosure credentials)

kinds (namespace)

Not part of the closed tag vocabulary — the resolver mechanism is extensible — but the kinds ChainRender ships as first-party, surfaced with their KIND constants + arg encoders (re-exported from the drift-locked mirrors) so an app, a builder, an MCP server, or an AI can discover and encode them. Also in vocabulary().resolverKinds.

Source: chainc/resolverkinds.ts

reads (namespace)

v0.11.0: generic on-chain reads — arg encoders for the staticread (CallResolver: any view function on any co-located contract, STATICCALL-only) and multiread (MultiCallResolver) slots; the most common way an app shows its own contract's state. reads.staticReadSlot(resolver, { target, callData: reads.callData("totalSupply()") }).

Source: chainc/callresolver.ts

appmeta (namespace)

App metadata: the single source of truth for on-chain app titles/authors/etc. (see chainc/appmeta.ts).

Source: chainc/appmeta.ts

RESOLVER_KINDS

const RESOLVER_KINDS: ResolverKindDescriptor[] = [ … ]

The first-party on-chain resolver kinds ChainRender ships, drift-locked to their mirrors.

Source: chainc/resolverkinds.ts

v0.4.0: Naming / submission helpers (docs 72/86)

labelHashOf

function labelHashOf(label: string): `0x${string}`

labelHash = keccak256(utf8 bytes of the subname label) — mirrors SubnameStakeRegistrar.labelHashOf.

Source: chainc/submission.ts

SPAM_TOPIC

const SPAM_TOPIC = stringToHex("spam", { size: 32 })

The topic an attester publishes to flag spam (right-padded into bytes32) — mirrors SPAM_TOPIC.

Source: chainc/submission.ts

SubmissionStatus

enum SubmissionStatus

Submission status — mirrors SubnameStakeRegistrar.Status. Enum order is load-bearing (matched on-chain).

Source: chainc/submission.ts

isLive

function isLive(status: SubmissionStatus): boolean

A submission is live (resolves to its component) only when Active or Refunded — mirrors resolves().

Source: chainc/submission.ts

v0.4.0: Theming (design tokens + CSS generation)

defaultTokens

function defaultTokens(): ThemeTokens

── DEFAULT tokens — grounded in the LIVE seeded theme (not invented), extended to the full surface with sane fail-closed defaults for the axes the CSS didn't previously tokenize. This is _defaultTokens()'s mirror. ──

Source: chainc/theme-tokens.ts

darkDefaults

function darkDefaults(): ThemeTokens

A standard DARK preset (doc 102) — EXACT mirror of ThemeTokens.darkDefaults(). Drift-locked.

Source: chainc/theme-tokens.ts

highContrastDefaults

function highContrastDefaults(): ThemeTokens

doc 107 gap #1 — high-contrast preset (WCAG AAA). Maximum legibility: near-pure black text on pure white, saturated accents chosen for >=7:1, thicker borders/focus for the non-text indicator floor (1.4.11). A THIRD preset alongside light/dark — the standard accessibility trio. Drift-locked + contrast-invariant-checked.

Source: chainc/theme-tokens.ts

toCss

function toCss(t: ThemeTokens): string

Generate the .cr-root CSS from tokens — the SAME values the palette inlines, so components + image renderers can't disagree. (On-chain, ThemeCssView produces this exact string; this is the mirror for the drift-lock.)

Source: chainc/theme-tokens.ts

toPalette

function toPalette(t: ThemeTokens)

The inlined palette image renderers use — literal values (never var()). Colors + the font scale + fonts.

Source: chainc/theme-tokens.ts

THEME_TOKENS_VERSION

const THEME_TOKENS_VERSION = 1

chainc/theme-tokens.ts — the SINGLE SOURCE OF TRUTH for ChainRender's design-token system (doc 98). From this one token set derive BOTH outputs, so components (CSS) and image renderers (inlined palette) can never diverge: • toCss(tokens) → the .cr-root CSS string (what components consume via the shadow root / ThemeCssView) • toPalette(tokens) → literal color/font values image renderers INLINE into SVG (never var(), which is inert inside an — the bug doc 98 fixes) Complete to the W3C Design Tokens taxonomy (color/dimension/fontFamily/fontWeight/number/duration/cubicBezier + composite typography/border/shadow/transition/gradient/strokeStyle) plus layering + breakpoints. Closed core + additive extension + version byte (fail-closed on unknown) — expandable, robust, upgradable, fully on-chain.

Source: chainc/theme-tokens.ts

LEGIBILITY_FLOOR

const LEGIBILITY_FLOOR = 12

The token model + the on-chain-identical CSS generators, so an SDK consumer (or a visual builder) can theme an app: pick a preset, edit tokens, and produce the exact .cr-root CSS the on-chain ThemeCssView produces.

Source: chainc/theme-tokens.ts

fullThemeCss

function fullThemeCss(tokens: ThemeTokens): string

The complete .cr-root CSS for a token set: the token variables (as ThemeCssView produces on-chain) plus the shared component rules.

Source: client/runtime/default-theme.ts

lightThemeCss

function lightThemeCss(): string

fullThemeCss() of the default light tokens.

Source: client/runtime/default-theme.ts

darkThemeCss

function darkThemeCss(): string

fullThemeCss() of the default dark tokens.

Source: client/runtime/default-theme.ts

v0.4.0: Verified-subname preflight (SubnameStakeRegistrarV2, docs 72/86 §5)

expectedEnsNode

function expectedEnsNode(label: string): `0x${string}`

/ The ENS node a VERIFIED claim of label must prove ownership of: namehash(<label>.eth) = / keccak256(namehash("eth"), keccak256(label)). Equals SubnameStakeRegistrarV2.expectedEnsNode(label) and / viem's namehash(label + ".eth"). Use it to build the registerVerified call and preflight the binding.

Source: chainc/submission-v2.ts

isValidLabel

function isValidLabel(label: string): boolean

/ True iff label passes the on-chain charset/normalization gate: non-empty, <= MAX_LABEL_LEN, lowercase ASCII / [a-z0-9-], no leading/trailing hyphen, no consecutive hyphens. Mirrors SubnameStakeRegistrarV2.isValidLabel — / categorically excludes homoglyph/confusable/whitespace/mixed-case spoofs. Preflight before register().

Source: chainc/submission-v2.ts

ETH_NODE

const ETH_NODE = "0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae" as const

/ namehash("eth") — the parent under which a verified label's name must exist (mirrors ETH_NODE in the contract).

Source: chainc/submission-v2.ts

MAX_LABEL_LEN

const MAX_LABEL_LEN = 63

/ The maximum label length the registrar accepts (mirrors MAX_LABEL_LEN).

Source: chainc/submission-v2.ts

Types

TypeScript types exported here (type-only: import type { … }):

@chainrender/client/runtime

Off-chain runtime: render a deployed component with a free eth_call, fill its slots, turn declared actions into wallet requests, events, themes, local state.

import { renderComponent } from "@chainrender/client/runtime";

Exports

renderComponent

async function renderComponent(dep: Deployment, hash: string): Promise<string>

Renders a stored component by its content hash through the RenderRouter (free eth_call). Returns the on-chain interpreter's HTML string — already escaped and safe to insert into an isolated container (a shadow root or sandboxed iframe under a strict CSP).

Source: client/runtime/core.ts

enumerate

async function enumerate(dep: Deployment): Promise<ComponentMeta[]>

Enumerates the registry (proof-of-concept on-chain list; a production app would use an event indexer — see the Explorer README). Returns each component's hash + basic metadata.

Source: client/runtime/core.ts

decodeAbiString

function decodeAbiString(hex: string): string

Decodes an ABI-encoded dynamic string return value (offset, length, data).

Source: client/runtime/core.ts

splitArgs

function splitArgs(raw: string): string[]

Splits an args template on top-level commas only, so bracketed/parenthesised groups (arrays, tuples) stay intact: "0xabc,[1,2,3],(x,y)" -> ["0xabc","[1,2,3]","(x,y)"].

Source: client/runtime/core.ts

SELECTORS

const SELECTORS = { … } as const

Function selectors for the RenderRouter / ComponentRegistry view functions used here. Precomputed (keccak of the signature, first 4 bytes) so the client needs no crypto lib.

Source: client/runtime/core.ts

bindSlots

async function bindSlots(root: ParentNode, resolvers: SlotResolvers): Promise<void>

Fills every [data-cr-bind] slot under root using the matching resolver, except cr: slots (see isCrArg). root can be a shadow root, an element, or a document fragment. For <img> slots the resolved value is a validated image src set on the element; for all other slots it is inserted as textContent (never parsed as HTML). Filled slots get the cr-filled class; slots with no matching resolver keep their on-chain fallback.

Source: client/runtime/bind.ts

readAction

function readAction(el: Element): ActionDeclaration | null

Reads a declarative submit action off a rendered button (its data-cr-* attributes), or null if the element carries no action.

Source: client/runtime/bind.ts

readActions

function readActions(root: ParentNode): ActionDeclaration[]

Collects every declared submit action under root.

Source: client/runtime/bind.ts

isValidImageSrc

function isValidImageSrc(src: string): boolean

Validates an image src the same way the on-chain interpreter does: only base64 data URIs for svg/png/jpeg, whose body is pure base64. Refuses javascript:, data:text/html, external URLs, and any body containing quotes/brackets — defense in depth on the client side.

Source: client/runtime/bind.ts

isCrArg

const isCrArg = (arg: string | null | undefined): boolean => …

No doc comment in the source.

Source: client/runtime/bind.ts

renderComponentWithContext

async function renderComponentWithContext(dep: Deployment, hash: `0x${string}`, ctx: PresentationContext): Promise<string>

Render a stored component through the RenderRouter with a presentation context (free eth_call). Returns the on-chain interpreter's HTML — escaped and safe to insert into an isolated container, as with renderComponent().

Source: client/runtime/context.ts

renderWithContextCalldata

function renderWithContextCalldata(hash: `0x${string}`, ctx: PresentationContext): `0x${string}`

The eth_call data for renderHashWithContext(hash, ctx).

Source: client/runtime/context.ts

RENDER_WITH_CONTEXT_ABI

const RENDER_WITH_CONTEXT_ABI = [ … ] as const

The RenderRouter function this calls (contracts/RenderRouter.sol).

Source: client/runtime/context.ts

staticResolvers

const staticResolvers: SlotResolvers = { … }

Resolvers that need no chain access — safe defaults that work offline.

Source: client/runtime/resolvers.ts

makeProviderResolvers

function makeProviderResolvers(provider: EnsBalanceProvider): SlotResolvers

Builds resolvers backed by a provider (e.g. a viem PublicClient), for the bindings that need live data. Merge over staticResolvers for full coverage:

Source: client/runtime/resolvers.ts

resolveArgs

function resolveArgs(action: ActionDeclaration, inputs: Record<string, string> = {}): string[]

Resolves $name argument references against form inputs; literals pass through unchanged.

Source: client/runtime/submit.ts

buildActionRequest

function buildActionRequest(action: ActionDeclaration, inputs: Record<string, string> = {}): TxRequest

Builds the calldata + tx request for a declared action, filling $input refs from inputs.

Source: client/runtime/submit.ts

describeAction

function describeAction(action: ActionDeclaration, inputs: Record<string, string> = {}): string

A plain-language description of what a declared action would do, for user review before signing. Always show this — never trust the button's own label.

Source: client/runtime/submit.ts

events (namespace)

EventSource deferred-lock-in family + readEvents — doc 94. Namespaced to avoid the custom collision with the ThemeSource family (both families ship a custom escape hatch).

Source: client/runtime/events.ts

MULTICALL3

const MULTICALL3 = "0xcA11bde05977b3631167028862bE2a173976CA11" as const

Canonical deterministic Multicall3 (mds1/multicall3) — same address on every chain that has it deployed.

Source: client/runtime/batch.ts

batchRead

async function batchRead(specs: readonly CallSpec[], opts: { rpc: string; multicall?: `0x${string}` },): Promise<BatchResult[]>

Execute specs via Multicall3.aggregate3 in one eth_call. Order-preserving; each call fails closed independently.

Source: client/runtime/batch.ts

themes (namespace)

The on-chain theme render path — ThemeSource family (sourceStore/bundled/custom) + applyTheme + renderToShadow (doc 90, Phase 3). Namespaced as a sibling of events.

Source: client/runtime/theme.ts

DEFAULT_THEME_CSS

const DEFAULT_THEME_CSS = ".cr-root{display:block;box-sizing:border-box;padding:var(--cr-space-md,12px);line-height:1.5;text-align:left;letter-spacing:normal;\n font-family:var(--cr-font, system-ui, …

client/runtime/default-theme.ts — the COMPLETE bundled default theme (Phase 3, theme-finish). BASE component theme (.wrap block: buttons/inputs/slots/headings/images/alerts/timeline/steps) + a11y INTERACTION states, --cr--tokenized, scoped under .cr-root. Explicit inherited-property resets (line-height/text-align/letter-spacing) for shadow isolation WITHOUT all:initial (which was found to interfere with the --cr- token override / theming). Highlighted states filled + contrast-robust. 13 vars.

Source: client/runtime/default-theme.ts

local (namespace)

LocalStore family (memory/localStorage/indexedDB/custom) + settle — optimistic-local-state + on-chain settlement (doc 94, Phase 3 sub-step 4). Namespaced (custom collides with events/themes families).

Source: client/runtime/local.ts

Types

TypeScript types exported here (type-only: import type { … }):

@chainrender/client/react

React adapter over the runtime (react is a peer dependency).

import { useChainRenderComponent } from "@chainrender/client/react";

Exports

useChainRenderComponent

function useChainRenderComponent(deployment: Deployment, hash: string): UseComponentResult

Fetches a component's on-chain-rendered HTML by hash. Re-fetches when hash/deployment change or when refetch() is called.

Source: client/react/react.ts

ChainRenderView

function ChainRenderView(props: ChainRenderViewProps)

Renders a ChainRender component into a style-isolated shadow root and fills its slots. The interpreter's HTML is already escaped; rendering into a shadow root keeps the host page's styles out and the component's markup contained.

Source: client/react/react.ts

Types

TypeScript types exported here (type-only: import type { … }):

@chainrender/client/miniapp

Farcaster Mini App distribution: manifest, embed tags, identity, wallet, notifications — all fail-closed outside a Farcaster host.

import { capabilitiesForEnvelope } from "@chainrender/client/miniapp";

Exports

capabilitiesForEnvelope

function capabilitiesForEnvelope(envelope: number): string[]

Map a ChainRender capability envelope (the honesty bits) to the Mini App SDK capabilities the host must support. This carries ChainRender's capability honesty through to the Mini App layer: if the app declares on-chain writes/value/signing, it declares it needs a wallet provider here too.

Source: client/miniapp/manifest.ts

buildManifest

function buildManifest(cfg: MiniAppConfig, accountAssociation?: AccountAssociation): Record<string, unknown>

Build the /.well-known/farcaster.json manifest. Serve it at that path on homeUrl's domain. Without an accountAssociation the app still runs as a standard web app / unverified Mini App; with it, the domain is provably owned by your FID and the app is discoverable + can notify.

Source: client/miniapp/manifest.ts

buildEmbed

function buildEmbed(embed: EmbedConfig): Record<string, unknown>

Build the embed object placed in the fc:miniapp meta tag on any page that shares the app.

Source: client/miniapp/manifest.ts

buildEmbedMetaTags

function buildEmbedMetaTags(embed: EmbedConfig): string

Render the embed as HTML meta tags — emits fc:miniapp plus the legacy fc:frame alias for hosts still on the older tag. Inject the result into the page <head>.

Source: client/miniapp/manifest.ts

inMiniAppHost

async function inMiniAppHost(): Promise<boolean>

Whether we're running inside a Mini App host (a Farcaster client webview). False for a plain page.

Source: client/miniapp/runtime.ts

signalReady

async function signalReady(opts?: { disableNativeGestures?: boolean }): Promise<void>

Signal to the host that the app has finished loading and can be shown. MUST be called once the ChainRender render is on screen, or the host shows an infinite splash. No-op outside a host.

Source: client/miniapp/runtime.ts

mountChainRenderApp

async function mountChainRenderApp(render: () => void | Promise<void>): Promise<void>

Render the ChainRender floor first, then signal ready. render is your own mount (e.g. inject the HTML from an eth_call into the DOM). The floor is visible even if the host/SDK never resolves.

Source: client/miniapp/runtime.ts

currentUser

async function currentUser(): Promise<FarcasterUser | null>

The current Farcaster user from host context (no signature), or null outside a host. Use this for a lightweight FID read; use signInWithFarcaster to get a verifiable SIWF credential.

Source: client/miniapp/runtime.ts

signInWithFarcaster

async function signInWithFarcaster(nonce: string): Promise<FarcasterUser | null>

Sign In With Farcaster: returns the FID + a SIWF message/signature to verify on your server, or null outside a host. nonce should come from your server to bind the session. Fails closed.

Source: client/miniapp/runtime.ts

enableNotifications

async function enableNotifications(): Promise<boolean>

Prompt the user to add the app, which enables notifications (the host then delivers a notification token to your manifest webhookUrl — send with sendMiniAppNotification server-side). Returns whether the prompt was shown; false outside a host.

Source: client/miniapp/runtime.ts

miniAppWalletProvider

async function miniAppWalletProvider(): Promise<unknown | null>

The host's embedded EIP-1193 wallet provider — the final gate for a ChainRender WRITE_CHAIN action when embedded — or null outside a host (fall back to the user's own injected wallet).

Source: client/miniapp/runtime.ts

sendMiniAppNotification

async function sendMiniAppNotification(n: NotificationSend): Promise<Response>

POST a Mini App notification to the host. Returns the raw Response; inspect it for the per-token result (delivered / rate-limited / invalid) per the Mini App spec. Server-side only.

Source: client/miniapp/notify.ts

Types

TypeScript types exported here (type-only: import type { … }):