Runtime Compatibility Baseline

LERP tracks runtime source, public documentation, and editor rollout as separate claims. A declaration in one lane does not establish availability in another.

Accepted baseline

• Audit date: September 4, 2026
• Direct Web runtime packages: @rive-app/canvas@2.42.0, @rive-app/canvas-lite@2.42.0, @rive-app/webgl2@2.42.0, and @rive-app/canvas-advanced@2.42.0
• Web package gitHead: cb8b0d6a679746c77e33bee3f47a0fb749e25b9c
• C++ runtime: runtime-v0.1.344
• C++ runtime commit: d619bc2a83f3c592a57eb58b9c83315142bcfbfc
• Runtime refs: released tag, canary, and main all resolve to that commit
• Landing integration: @rive-app/react-canvas@4.34.0, resolving @rive-app/canvas@2.42.0
• Web 2.42 host delta: experimental enableGPUCanvas import mode, defaulting to false; the embedded C++ runtime and Luau surface remain runtime-v0.1.344
• Public docs snapshot: Rive's llms-full.txt, retrieved August 31, 2026
• Supporting evidence: current editor/LSP declarations, official docs, runtime source, and reviewed script examples

Exact target

Course examples and the bundled React landing target Web 2.42.0 backed by runtime-v0.1.344.

All six checked-in .riv paths have file-format 7.0 headers and collapse to three unique payloads. The direct-runtime harness loads every path through both Canvas 2.42.0 and WebGL2 2.42.0, starts its first state machine, and checks that a non-empty frame is rendered without a page, request, or Rive load error. Because all files predate format 7.3, this run also exercises runtime 341's retained compatibility path in the accepted runtime 344. Header inspection establishes the version only; the runtime run establishes pixels. The separate landing preview uses the preferred singular stateMachine option.

Evidence lanes

Lane	What it establishes	What it does not establish
Released runtime source	A binding, dispatch path, or behavior exists in the exact C++ target	Public docs, editor availability, or a successful exported Web run
Public Rive docs	Rive publishes a signature or workflow	Presence in the exact C++ Luau target
Editor reference/analyzer	The current editor exposes and checks a declaration	Availability in Web 2.42.0 or runtime execution
Live/editor execution	A focused case works in the observed editor environment	Other hosts, exports, or untested callbacks
Later source	An implementation exists after the accepted runtime commit	Publication or support at the accepted target
Serialized host data	Runtime/editor assets contain implementation metadata	A Luau global, type, or callable API exists

Released target surface

Surface or behavior	Target status	Course treatment
Context:globalViewModel(name) and Context:globalViewModelNames()	Source-confirmed in runtime-v0.1.344; current public/editor references agree	Released target API. Unknown or non-global names return nil; no attached file yields an empty names array.
Layout resize(self, size, displayScale)	Source-confirmed three-argument Luau dispatch and scale-change redispatch; missing resize is a no-op	Optional target callback. displayScale is device pixels per layout point. Existing two-parameter Luau callbacks remain compatible because extra arguments are ignored.
Retired drawCanvas callback	No current target dispatch; serialized legacy method metadata may remain	Keep Canvas/GPUCanvas work in draw(self, renderer). Do not add drawCanvas to scripts.
WASM scripting lane	Released runtime implementation	Host/runtime capability. It does not add a Luau global by itself.
RASC workspace and test protocol	Released source contains the editor/compiler protocol and in-memory bake path	Tooling boundary. Do not model the private workspace protocol as callable Luau.
Compiled module-handle reaping	Released host lifecycle fix	Internal resource management; no course signature.
Luau rive_0_734 baseline	Released language-engine update	Engine baseline only; do not infer unsupported syntax changes.
ScriptAsset module	An authored Luau script whose host isModule flag is true	Import by its authored require("Name"); the flag itself is not a Luau global.
ScriptModuleAsset	Separate self-contained compiled WASM host payload with language metadata, VM, bindings, and compiled scripts	It is not a Luau type, global, or require name. Serialized fields and internal IDs remain host data.
TextInput alignment metadata	Serialized alignValue key 222 and verticalAlignValue key 1094	Serialized/editor metadata, not Luau TextInput fields.
Focus and gamepad corrections	Released fixes cover device indexing, root-artboard FocusManager ownership, re-homing focus, visibility transitions, and destroyed focus-tree state	Existing event callback signatures are unchanged; re-test controller and nested-artboard focus behavior.
Layout and animation corrections	Released fixes cover integer grid placement, bound keyframes, Yoga writes, Solo sizing, nested Fill/Hug, component-list parent discovery, nonzero nested-artboard origins, and a generated layout matrix	The Layout callback gains displayScale; other changes are behavioral. Re-test affected files.
Nested-artboard semantic state	Released state ownership moved to the nested instance	Lifecycle/semantic correction; no new Luau method.
Text rendering and TextInput behavior	Released font-fit, feathering, dirt/hug/edit/font corrections	Behavioral baseline; serialized fields remain separate from script event payloads.
Web heap views	Web bindings rebuild typed heap views from wasmMemory for the newer Emscripten toolchain	Embedder/runtime repair; no Luau API.
WASM script-host hardening	Runtime 344 includes frame-generational collection and checked handles, keeps tier compilation/transplant tools-only, and adds native main/global ViewModel command-queue retrieval	Host behavior only; it adds no Luau or public Web-wrapper call.
Pre-7.3 text compatibility	Runtime 341's file-version gate is retained in runtime 344	Layout-controlled auto-sized text authored before format 7.3 uses the legacy sizing/overflow behavior. Validate pixels in real exports.
Web state-machine selection	Web 2.42.0 prefers singular stateMachine for constructor, load, and reset; it takes priority over legacy playback parameters	Use singular selection in new integrations. Plural stateMachines remains callable on the 2.x line while integrations migrate.
Legacy Web controls	Direct state-machine inputs, Rive/state-change events, text-run controls, and multiple playback remain present in Web 2.42.0 with deprecation guidance	Do not describe these APIs as removed. Prefer ViewModel data binding and one state machine for new work.
Web enableGPUCanvas	Web 2.42.0 exposes an experimental, default-false host option that imports GPU Canvas content through deferred rendering	Configure it when constructing/loading a Web Rive or RiveFile; it is not a Luau global or LSP declaration. A file's mode is fixed at import, and a supplied RiveFile keeps its own setting. This record does not claim that RAV or any other host enables the option.

The upstream script_dependency_test.riv fixture contains six ScriptAsset records: one protocol converter and five dependencies marked isModule = true. Its runtime test exercises a chained Luau require path. The file contains no serialized ScriptModuleAsset record (type 1071), so it does not validate the compiled WASM/RASC module lane.

The release also contains renderer, focus, text, and layout fixes that can change the result of an existing .riv without changing its script. Treat a clean compile as necessary evidence, then run the real layout, text, focus, or nested artboard fixture in the selected editor/export lane.

Pre-7.3 layout-controlled text check

Web 2.42.0 embeds runtime 344, which retains runtime 341's repair for layout-controlled auto-sized text authored before file format 7.3. The LERP asset inventory found six checked-in .riv paths, three unique payloads, all with 7.0 headers. Because the header cannot prove whether a file contains the affected layout/text combination or what it draws, every checked-in path is run through both released renderer packages.

The exact observed result was:

Payload	Runtime result
Header paths	Canvas and WebGL2 loaded State Machine 1; non-empty pixels rendered with no page/load error
Desktop hero paths	Canvas and WebGL2 loaded State Machine 1; non-empty pixels rendered with no page/load error
Portrait hero paths	Canvas and WebGL2 loaded State Machine 1; non-empty pixels rendered with no page/load error

The run did not compare against a pre-341 known-good pixel reference, so it does not prove pixel identity or that every animation state is unaffected. It does prove both released renderer packages loaded and drew each checked-in path through the compatibility branch.

Current public and editor surface

These declarations are useful for editor authoring. The table keeps host-only surfaces distinct from the exact C++ runtime even when both are current.

Surface	Current evidence	Boundary
FileFormat / TextFileFormat	Current public docs, editor/LSP declarations, and a reviewed shipped .rsvg implementation	Editor extension protocols. Text documents export as Blob assets and runtime scripts read them with context:blob(name).
FormatDocument, FormatView, EditorContext, tokens, diagnostics, completion, and hover records	Current editor/LSP declarations	Callback/data/view surface for FileFormat scripts, not serialized host JSON.
Context.log	Current editor reference declares log: (message: string) -> ()	Function-valued property called with context.log(...). No matching C++ Luau Context dispatch exists in runtime-v0.1.344; use print(...) for portable target scripts.
Layout resize(self, size, displayScale)	Runtime 344, current editor/LSP declarations, and runtime tests agree	Released optional callback. Scale changes are redispatched after a valid size; an unchanged scale is silent. Two-parameter callbacks remain compatible.
Tester:blob(name)	Current editor reference	Editor test helper; verify the current editor when a test depends on an asset.

The reviewed official-docs checkout did not yet contain the FileFormat API pages. The current public machine-readable docs and editor/LSP declarations therefore provide newer evidence than that snapshot.

See File Formats for the callback contracts and a minimal TextFileFormat example.

Web GPU Canvas host opt-in

Web 2.42.0 adds enableGPUCanvas?: boolean to the JavaScript Rive, load, and RiveFile parameter surfaces. It is experimental and false by default. When enabled for a file loaded from src or buffer, the Web host imports the file into a deferred rendering session so GPU Canvas content can draw.

The choice is fixed when the file is imported. If an integration supplies an already-created RiveFile, that file's enableGPUCanvas setting wins. Create or load a new file to change modes. In React Canvas 4.34.0, the same option is forwarded to Canvas 2.42.0; GPU Canvas recording and the shared offscreen renderer are incompatible, so do not explicitly force both modes on. A build that cannot create a deferred session warns and falls back to immediate import; the flag by itself is not render evidence.

This is JavaScript host configuration. It does not add a Luau name, change the runtime 344 declarations, or prove that an editor, exported app, RAV, or any other wrapper packages and enables GPU Canvas content. The LERP landing leaves the option off because its checked-in assets do not require it. Validate each host with an exported GPU Canvas fixture before calling that host supported.

Adjacent findings and non-API boundaries

Finding	Course treatment
TextInput obscured key 1095	Retained in runtime 344 as serialized/editor metadata. It is not a Luau TextInput field.
SemanticData mixed-state removal/tri-state behavior	Retained in runtime 344; no LERP Luau signature changes.
Layout display scale	Introduced in runtime 335 and released in the accepted runtime 344; teach the three-argument optional callback and old-callback compatibility.
Runtime 337 layout matrix	The generated cross-runtime matrix and test-only inspection helpers establish layout behavior. They add no Luau method beyond the scale-aware callback.
State-machine import tolerance	Runtime 338 tolerates layers without Any/Exit while still requiring Entry. This importer behavior adds no LERP API and has no checked-in fixture.
WASM host hardening	Runtime 339 adds frame-generational collection and checked handles; 342 restricts tier compilation/transplant to tools builds. These are released host changes, not Luau calls.
Pre-7.3 text compatibility	Runtime 341 restores legacy layout-controlled text sizing/overflow by file version; direct Web 2.42.0 runtime smokes exercise the branch with the checked-in format 7.0 files.
ViewModel command queue	Runtime 343 adds native main/global ViewModel retrieval callbacks. This is a released host path, not a Luau or public Web-wrapper method.
Renderer/Vulkan	Runtime 340 restructures image draw instances; 344 adds Vulkan multi-swap-chain synchronization. Neither adds a LERP call.
Runtime 337 through 344 API range	No generated serialization or public Lua/Luau protocol delta beyond Layout display scale was found.

FileFormat and runtime asset boundary

FileFormat and TextFileFormat are callable editor protocols. Their documents, views, and analysis callbacks are real Luau surfaces in the current editor. The following neighboring data remains non-callable:

• serialized host asset records
• serialized type/property keys and internal asset IDs
• implemented-method bitsets
• ScriptModuleAsset language values and compiled module handles
• RASC workspace messages and compiler bookkeeping

A custom text document becomes a normal Blob on export. The runtime-facing contract is therefore:

local source = context:blob("DocumentName")
if source then
    if source.size == 0 then
        print("")
    else
        local data = source.data
        if data then
            print(buffer.tostring(data))
        end
    end
end

The runtime 344 Blob has name, size, and data fields only. Its data field is nil when the Blob has zero bytes.

The editor callback contract and the exported runtime Blob contract should be tested independently.

Protocol and lifecycle guidance

• Keep callback state on self; FileFormat analysis callbacks are pure functions of (doc, parsed), while per-surface state belongs in a FormatView.
• Keep module imports on the authored ScriptAsset name through require("ModuleName"). A ScriptModuleAsset, workspace ID, compiled handle, language value, or internal ID belongs to the host.
• Keep drawCanvas retired. Pair Canvas/GPUCanvas frame or render-pass work inside draw(self, renderer) and composite there.
• Treat Layout resize as optional. At the accepted target, write resize(self, size, displayScale) when scale matters. Existing two-parameter callbacks remain valid.
• Keep global ViewModel handles or properties alive when listeners depend on them. Unknown names must be handled as nil.
• Re-run focus, nested-artboard, TextInput, and custom-layout fixtures after a runtime update because the accepted release changes behavior without adding script calls.

Validation record

The September 4 pass used this sequence:

1. Verified all four direct Web 2.42.0 packages, their shared package gitHead, and runtime-v0.1.344 independently.
2. Verified that Web 2.42.0 still points to C++ commit d619bc2a83f3c592a57eb58b9c83315142bcfbfc, preserving the completed runtime 344 Luau/WASM dispatch and lifecycle audit rather than inferring a new Luau surface from a Web-wrapper release.
3. Compared current public Rive docs, the current editor/LSP declarations, official-docs snapshots, runtime source, and reviewed script examples.
4. Reconciled each accepted runtime change through 344, preserving the 337 layout-matrix origin as historical detail. Layout display scale is the callable Luau protocol change in that range; the remaining findings are behavior or host internals.
5. Reconciled Web 2.42.0 declarations and wrapper behavior for singular stateMachine, legacy 2.x compatibility, and experimental/default-off enableGPUCanvas, including its import-fixed RiveFile boundary.
6. Inventoried every checked-in .riv path, treated all three unique 7.0 payloads as possible pre-7.3 text cases, and rendered every path with Canvas and WebGL2 2.42.0 instead of treating static headers as pixel evidence.
7. Ran course generation, type checks, production build, route/link/anchor/feed checks, and focused Luau analysis, recording pre-existing toolchain conditions rather than converting them into API claims.

Known validation limits

• All six bundled .riv paths were executed through Canvas and WebGL2 2.42.0. They loaded and rendered non-empty frames, but no pre-341 reference image was available for exact pixel comparison.
• No focused exported Luau fixture was executed for the scripting callbacks documented in this rebaseline.
• The live editor reference was read without mutating the open Rive file.
• FileFormat callback execution was not repeated in the live editor; the callable surface is supported by current public/editor/LSP declarations and a reviewed shipped .rsvg implementation.
• Final canonical analyzer runs completed without diagnostics for the existing runtime fixture and the binary/text FileFormat fixtures. Static acceptance still does not replace editor callback or exported-runtime execution.
• No checked-in GPU Canvas export fixture exercises enableGPUCanvas, and no RAV support claim was tested or made. The documented flag behavior is based on the exact Web 2.42.0 package declarations and wrapper source.

Historical baselines

Previous LERP releases preserve their original evidence in the changelog and errata tracker:

• 1.4.0 (September 1, 2026): Web 2.41.1 / runtime-v0.1.344, landing React Canvas 4.33.1, and the initial runtime 344 source and renderer rebaseline.
• 1.3.0 (August 14, 2026): Web 2.40.0 / runtime-v0.1.271, with a separate evidence-only runtime-v0.1.272 canary and focused editor probes.
• June 4, 2026 shader audit: Web 2.37.8 and source-level runtime-v0.1.106; shader/GPU workflows remained Rive Early Access.
• May 12, 2026 audit: Web 2.37.6 and source-level runtime-v0.1.64.

Historical version pins describe their releases only. New examples and the bundled landing use the September 4 target above.

Future re-audit checklist

1. Pin the released Web version, package gitHead, C++ runtime tag, and commit.
2. Keep serialized host records separate from callable Luau declarations.
3. Inspect binding declarations and dispatch paths, including missing-method behavior.
4. Compare public docs, editor reference, local docs, and live execution as separate evidence lanes.
5. Run an exported runtime fixture for behavior-sensitive changes; for pre-7.3 layout-controlled text, compare rendered output when possible.
6. Update this page, API/protocol lessons, errata, changelog, generated AI artifacts, and the LSP reconciliation manifest.