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 14, 2026
• Direct Web runtime packages: @rive-app/[email protected], @rive-app/[email protected], @rive-app/[email protected], and @rive-app/[email protected]
• Web package gitHead: e0bfcec3ccd0f1dee01686776da68f439a95cbfa
• C++ runtime: runtime-v0.1.384
• C++ runtime commit: 45d4d01dfd1fe70d3f9e73764538c16f63a04d07
• Runtime refs: released tag resolves to that commit; canary (runtime-v0.1.399 / 1cdd96e32f8a7366ed682e834a4d84def51498ed) and public main are strictly ahead and recorded as later-source evidence only, never as released — see RIVE-0012
• Landing integration: @rive-app/[email protected], resolving @rive-app/[email protected] — not bumped this audit; see Landing integration lag
• Web 2.42.1 host delta: none versus 2.42.0. git diff of the rive-wasm tags for those two npm releases touches only version-bump package.json/CHANGELOG.md files and the wasm/submodules/rive-runtime gitlink; js/src/rive_advanced.mjs.d.ts is byte-identical between them. enableGPUCanvas import mode remains experimental, defaulting to false; the embedded C++ runtime and Luau surface move from runtime-v0.1.344 to runtime-v0.1.384
• Public docs snapshot: Rive's llms-full.txt, retrieved August 31, 2026 (unchanged this audit; re-check before the next runtime bump)
• Supporting evidence: current editor/LSP declarations, official docs, runtime source, and reviewed script examples. The Rive editor MCP was not connected during this audit; every editor-tier claim below is explicitly marked not editor-validated this run rather than inferred from source alone

Exact target

Course examples target Web 2.42.1 backed by runtime-v0.1.384. The bundled React landing still targets Web 2.42.0 / runtime-v0.1.344 — see Landing integration lag.

Landing integration lag

The direct course target moved to Web 2.42.1 / runtime-v0.1.384 in this audit. landing/package.json still pins @rive-app/[email protected] (resolving @rive-app/[email protected] / runtime-v0.1.344), one wrapper patch behind.

Disposition: blocked-pending-live-test. Bumping the landing dependency requires live-testing the built landing (npm --prefix landing run build, then loading the bundled hero .riv and confirming the Rive canvas mounts without console errors) before trusting the bump. This audit had no browser-automation tool available (no Playwright/Puppeteer-equivalent, and WebFetch explicitly cannot load a local dev/build server) to perform that check, so the dependency was left unchanged rather than bumped unverified.

This lag is low-risk: the published @rive-app/[email protected] and 2.42.1 .d.ts are byte-identical (see the host-delta bullet above), so the landing's resolved runtime differs from the course's direct target only by the unrelated runtime-v0.1.344 -> runtime-v0.1.384 C++ range documented on this page — none of which changes a public Web declaration. Re-attempt the bump with a live-test tool available, or once a further Web release forces the question.

All six checked-in .riv paths have file-format 7.0 headers and collapse to three unique payloads. Carried forward from the September 4, 2026 pass, not re-run this audit: the direct-runtime harness loaded every path through both Canvas 2.42.0 and WebGL2 2.42.0, started its first state machine, and checked that a non-empty frame rendered without a page, request, or Rive load error. This audit had no browser-automation tool available to re-execute that harness against 2.42.1 (see Landing integration lag for the same constraint), so the pixel result below is evidence-tier live/editor execution, dated 2026-09-04 rather than a fresh 2.42.1 run. Source review of the d619bc2a..45d4d01d range found no change to the pre-7.3 text-gate logic itself (Text::import's existing atLeast(3)-style check is untouched; only the new, independent atLeast(4) fitFontSizeResizesBox gate was added — see the Released target surface table above), so the September 4 pixel result is treated as still applicable, on that source-review basis, not because it was re-observed at 2.42.1. 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.1 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

Evidence basis for every row in this table and the next is runtime/source-confirmed (verified independently against the exact d619bc2a..45d4d01d C++ diff and named commits in /Users/ivg/github/rive-runtime during this audit) unless the row says otherwise. No row in this table changed a released Luau callable signature in the runtime-v0.1.344 -> runtime-v0.1.384 range; the reviewed include/rive/lua, src/lua, src/scripted, and scripting test paths carry only tooling/lifecycle commits (a VS Code Luau script debugger, nested canvas/GPU render-pass reclaim ordering, a decodeImage wasmMemory fix) with no Luau-visible signature delta.

Surface or behavior	Target status	Course treatment
NestedArtboardLeaf.fitToLayoutParent (key 1098, bool, default false)	Runtime/source-confirmed, runtime-v0.1.358 (commit 3b2c51e2, PR #13977, fixing bug #13692). Editor-authored serialized toggle with RIVE_EDITOR_CHANGING/CHANGED hooks; no Luau accessor.	Not a Luau API — do not teach as a script call. When a NestedArtboardLeaf is parented by a Solo, this toggle picks corrected (true) vs. legacy (false) fit/alignment behavior; legacy leaves default false and keep pre-fix behavior on upgrade. Editor UI exposure is not editor-validated this run.
TextInput.selectAllOnFocus (key 1099, bool, default false)	Runtime/source-confirmed, runtime-v0.1.365 (commit 8551ef2b, PR #13997). Editor-authored serialized toggle; no Luau accessor.	Not a Luau API. When true, the input selects all contents on keyboard focus. Editor UI exposure is not editor-validated this run.
Text.fitFontSizeResizesBox (key 315, bool, default true) + file-format minor version 4	Runtime/source-confirmed, runtime-v0.1.384 (this release's own commit, PR #14074). Editor-authored serialized toggle; no Luau accessor. Gated by File::minorVersion (3 -> 4, include/rive/file.hpp) and consumed in Text::import()/fitFontSizeResizesBoxActive() (src/text/text.cpp).	Not a Luau API. A fitFontSize-overflow Text measures itself at its fitted size, not its authored box size — but only for files at file format 7.4+; older files keep the pre-fix unshrunk-box layout regardless of this value, matching the pre-7.3 compatibility pattern already on this page. RAV verification of live rendering is requested in the RFP handoff; not exercised in this audit.
Manifest watermark section + File::manifest()/auto-attached Watermark pre-roll	Runtime/source-confirmed, runtime-v0.1.350 (commit d8727299, PR #13930; ManifestSections::watermark, src/assets/manifest_asset.cpp, include/rive/watermark.hpp, src/watermark.cpp).	Not a Luau API — Watermark has no further serialized shape and no script surface. File::artboardDefault()/artboardAt()/artboardNamed() auto-attach the pre-roll to every vended top-level ArtboardInstance when a file's manifest has hasWatermark = true, freezing playback of the host artboard until the pre-roll finishes; bindableArtboardNamed()/bindableArtboardDefault() deliberately call instanceArtboard() directly and skip it, so a nested/bindable artboard never gets its own pre-roll. Whether this is a course-author-triggered export path or an editor/business-tier-only feature is not editor-validated this run — no watermark authoring lesson is added until that is confirmed. If any host in the LERP toolchain loads a watermarked export, its first-frame-is-host-content assumption should be re-verified.
ViewModel instance-value bindings inside list items; one data context per DataBindContainer	Runtime/source-confirmed, runtime-v0.1.372 (commit 85d7f952, PR #13998) and runtime-v0.1.367 (commit 6951a4b3, PR #13929). Behavior-only correctness fixes; no new serialized property.	No LERP Luau signature change. The course's vm:getList(name) / list.length / list[index] / list:addListener(...) API (ViewModels) is unaffected — these fixes correct data-binding delivery to values bound inside list-item templates in the editor, not the Luau list-reading API. Re-verify existing course ViewModel-list examples against the new runtime line was reviewed by source only; not live-tested this run.
Context:globalViewModel(name) and Context:globalViewModelNames()	Source-confirmed in runtime-v0.1.384 (unchanged from 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 384 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 through runtime 384; the new fitFontSizeResizesBox gate (file format 7.4) is a separate, later minor-version check layered on top, not a replacement	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.1 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.1 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.1 exposes an experimental, default-false host option that imports GPU Canvas content through deferred rendering; unchanged from 2.42.0 (byte-identical .d.ts)	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.
GPU-canvas / synchronous deferred rendering wrapper surface (js/rive.ts)	Traces to released-range runtime-v0.1.352 (Android GPU-canvas work, commit 39afeca4); independently confirmed unchanged between Web 2.42.0 and 2.42.1 — js/src/rive_advanced.mjs.d.ts is byte-identical between those two rive-wasm tags	No course action. This range's only Web-visible GPU-canvas work landed before the prior 1.4.1 baseline; nothing new crosses the public Web declaration surface in this 2.42.0 -> 2.42.1 step specifically.

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.1 embeds runtime 384, which retains runtime 341's repair for layout-controlled auto-sized text authored before file format 7.3, unchanged through this audit's 344 -> 384 range (see the Released target surface table above). 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 was run through both released renderer packages — on September 4, 2026, at 2.42.0/runtime 344; not re-executed this audit for the reason given above.

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.384; use print(...) for portable target scripts.
Layout resize(self, size, displayScale)	Runtime 384, 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.1 adds enableGPUCanvas?: boolean to the JavaScript Rive, load, and RiveFile parameter surfaces — unchanged from 2.42.0 (js/rive.ts and the public .d.ts are byte-identical between those two rive-wasm tags). 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. The LERP landing's bundled React Canvas 4.34.0 (still resolving Canvas 2.42.0; see Landing integration lag) forwards the same option to its resolved Canvas build; 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 384 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
SemanticData authored fields (role, label, value, hint, headingLevel, traitFlags, stateFlags, tri-state isChecked, type 668)	Schema predates this audited range unchanged (byte-identical include/rive/generated/semantic/semantic_data_base.hpp across d619bc2a..45d4d01d). RFP closed a parser-side extraction gap this release (these fields were always serialized but never walked by an extractor); that is a parser-JSON reporting change, not a runtime or Luau delta. Not a Luau API — do not teach features.semantics parser JSON as a script-readable surface.
TextInput obscured key 1095	Retained through runtime 384 as serialized/editor metadata. It is not a Luau TextInput field.
SemanticData mixed-state removal/tri-state behavior	Retained through runtime 384; no LERP Luau signature changes.
Layout display scale	Introduced in runtime 335 and released in the accepted runtime 384; 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.1 runtime smokes (dated 2026-09-04, carried forward — see above) 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.
64-bit RuntimeHeader::fileId() + malformed-boolean/unknown-ToC import safety	Runtime 348 widens the header file ID and adds a malformed import-result path for a previously-desyncing bool-typed unknown property. Import robustness only; no Luau surface, no course change.
decodeImage wasmMemory write path	Runtime 373 fixes a Web-wrapper-internal memory-growth bug (emsdk 4 no longer exports HEAPU8 on Module). Build-internal; both 2.42.0 and 2.42.1 already build against this fix. No course change.
Runtime 337 through 384 API range	No generated serialization or public Lua/Luau protocol delta beyond Layout display scale, the three new editor-authored toggles, and the manifest watermark section (all tabled above) was found.

Canary evidence — not released

runtime-v0.1.385 through runtime-v0.1.399 (public main/canary, strictly ahead of this audit's released runtime-v0.1.384 boundary) add a new PaintImage type, a ScriptedTransition/scripted-transition-child surface, a new BitmapCache type, UAX #14 unicode line breaking for text, and keyboard-input/focus-consumption improvements. None of this is released — no published @rive-app Web package embeds these commits. Per the suite's canary-routing policy, this is recorded as later-source evidence only; it must not be taught as available, and no course example, exercise, or compatibility row may reference ScriptedTransition, PaintImage, BitmapCache, or the UAX #14 line-breaking change as current. Re-check when a future release crosses this boundary.

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 384 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.
• Treat NestedArtboardLeaf.fitToLayoutParent, TextInput.selectAllOnFocus, and Text.fitFontSizeResizesBox as editor-authored serialized toggles, not Luau calls; their editor-UI exposure is not editor-validated this run.
• Do not build a watermark-authoring lesson from the manifest watermark section alone; its course-author-triggered vs. editor/business-tier status is unconfirmed. If a watermarked export is ever loaded in a LERP-adjacent host, expect the first rendered frame to be the pre-roll, not host content.

Validation record

September 14, 2026 pass

1. Verified all four direct Web 2.42.1 packages, their shared package gitHead (e0bfcec3ccd0f1dee01686776da68f439a95cbfa), and runtime-v0.1.384 independently, matching the RFP handoff (RUN_ROOT/rfp/handoff.json, sha256 376bc7ac490b9e648d1b84f50a2da36ee34d3d4238e26ead3761ea5eea7450ab).
2. Independently reviewed the exact d619bc2a..45d4d01d C++ source diff in /Users/ivg/github/rive-runtime for every finding routed to LERP (RIVE-0001, 0002, 0003, 0004, 0005, 0007, 0013), and confirmed by path-scoped git log/git show that no released Luau callable signature changed: the only commits touching include/rive/lua, src/lua, src/scripted, or the scripting test tree in this range are a VS Code Luau script debugger, nested canvas/GPU render-pass reclaim ordering, and the decodeImage wasmMemory fix — all tooling/lifecycle/build-internal, none Luau-signature-visible.
3. Independently verified the rive-wasm 2.42.0 -> 2.42.1 diff (cb8b0d6a..e0bfcec3) touches only version-bump package.json/ CHANGELOG.md files and the runtime submodule gitlink; js/rive.ts and js/src/rive_advanced.mjs.d.ts are byte-identical, confirming RIVE-0013.
4. Compared current public Rive docs, the current editor/LSP declarations, and reviewed script examples for the three new editor-authored toggles; found no editor UI exposure claim to confirm or refute, since the Rive editor MCP was not connected this run. Recorded each as not editor-validated this run rather than inferring rollout from source.
5. Decided not to bump the landing @rive-app/react-canvas dependency: no browser-automation tool was available to live-test the built landing after a bump (see Landing integration lag). Recorded blocked-pending-live-test, not a silent skip.
6. 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 (see docs/rive/rive-doc-errata.mdx and the suite report.md for exact commands/exit codes).
7. Did not re-execute the direct-runtime Canvas/WebGL2 pixel harness at 2.42.1 (no browser-automation tool available); carried the September 4 pixel result forward on a source-review basis (see the Pre-7.3 check above) rather than re-labeling it as freshly observed.

Known validation limits (September 14, 2026)

• No live Rive editor was available this run (the Rive editor MCP was not connected); every claim about editor UI exposure for the three new toggles is not editor-validated this run, sourced from C++ only.
• No browser-automation tool was available; the direct-runtime Canvas/WebGL2 pixel harness and the landing-bump live-test were both skipped rather than run unverified. Both are named explicitly above instead of being silently dropped.
• RAV's live rendering of a fitFontSize + hug-sized Text at file format 7.4, and RAV's playback of a watermarked export, are requested in the RFP handoff's downstream notes for RAV, not exercised by LERP.
• Existing course ViewModel-list examples were reviewed against the RIVE-0007 fix by source only (the fix is data-binding-delivery-only and does not touch the course's vm:getList/list[index] API surface); not re-run live.
• Final canonical analyzer runs completed without new diagnostics versus the established baseline (see changed-scripts.json); static acceptance still does not replace editor callback or exported-runtime execution.

September 4, 2026 pass (carried forward, historical)

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 pointed 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 was the callable Luau protocol change in that range; the remaining findings were 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.

Its own known limits (all still true, none re-tested this audit): all six bundled .riv paths were executed through Canvas and WebGL2 2.42.0 only (loaded and rendered non-empty frames, no pre-341 reference image for exact pixel comparison); no focused exported Luau fixture was executed for the documented scripting callbacks; the live editor reference was read without mutating the open file; FileFormat callback execution was not repeated live; no checked-in GPU Canvas export fixture exercised enableGPUCanvas, and no RAV support claim was tested.

Historical baselines

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

• 1.4.1 (September 4, 2026): Web 2.42.0 / runtime-v0.1.344 (unchanged from 1.4.0), landing React Canvas 4.34.0, and the experimental, default-off enableGPUCanvas host-option documentation pass.
• 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 use the September 14 direct target above; the bundled landing still targets the September 4 (2.42.0 / runtime-v0.1.344) line — see Landing integration lag.

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.
7. Re-attempt the landing dependency bump once a live-test tool (browser automation capable of loading the built landing and checking console errors) is available; do not bump on lockfile/registry evidence alone.