{ "schema": "sura.target.lowering_audit.v1", "generated_utc": "2026-07-16T15:11:24.7981994Z", "passed": true, "status": "INCOMPLETE", "lowering_complete": false, "ast_node_count": 43, "classified_node_count": 43, "unknown_nodes": [ ], "pipeline": { "ast_or_bytecode_frontend": true, "ast_json_export": true, "js_ast_json_input": true, "js_ast_import_expansion": true, "js_ast_full_target_smoke": true, "wasm_ast_json_input": true, "wasm_ast_import_expansion": true, "wasm_wat_instruction_boundary_guard": true, "js_frontend": "AST JSON full-target path plus source-line compatibility", "wasm_frontend": "AST JSON frontend for source and AST JSON input", "blocker": "WASM now uses the AST JSON frontend, but dynamic Value/function/class/exception node lowering is still partial." }, "js": { "full": 41, "ignored": 2, "partial": 0, "missing": 0, "unknown": 0, "complete": true }, "wasm": { "full": 27, "ignored": 2, "partial": 14, "missing": 0, "unknown": 0, "complete": false }, "incomplete_node_count": 14, "node_audits": [ { "node": "NUM_LIT", "kind": "expr", "js_status": "full", "wasm_status": "partial", "js_evidence": "Convert-SuraExpression emits JS literals", "wasm_evidence": "Raw numeric lowering currently emits the portable i32 subset. Fractional literals entering the tagged Value ABI use a tag-10 f64 payload and preserve values across mixed-type function parameters and returns, equality, type, and truthiness, but general arithmetic still truncates to i32.", "complete": false, "next_action": "extend f64 lowering from tagged Value boundaries into general numeric expressions, operators, locals, arrays, and exported functions" }, { "node": "STR_LIT", "kind": "expr", "js_status": "full", "wasm_status": "full", "js_evidence": "Convert-SuraStringLiteral handles strings", "wasm_evidence": "AST string literals lower to length-prefixed i32 code arrays, feed string concatenation/interpolation, and wrap through __sura_value_string for dynamic equality and truthiness candidates", "complete": true, "next_action": "none" }, { "node": "BOOL_LIT", "kind": "expr", "js_status": "full", "wasm_status": "full", "js_evidence": "true/false are JS literals", "wasm_evidence": "true/false lower to i32 constants", "complete": true, "next_action": "none" }, { "node": "NIL_LIT", "kind": "expr", "js_status": "full", "wasm_status": "full", "js_evidence": "nil lowers to null", "wasm_evidence": "AST nil lowers to an i32 zero sentinel and wraps through __sura_value_nil for dynamic equality, truthiness, interpolation, and assertion candidates", "complete": true, "next_action": "none" }, { "node": "IDENT", "kind": "expr", "js_status": "full", "wasm_status": "full", "js_evidence": "identifiers are preserved", "wasm_evidence": "local/global identifiers lower to i32 locals/functions", "complete": true, "next_action": "none" }, { "node": "BIN_OP", "kind": "expr", "js_status": "full", "wasm_status": "partial", "js_evidence": "normal-source and AST JSON JS paths route + and in through __sura_add/__sura_in; number/string/array addition and string/dict/array membership preserve tested VM results, while unsupported pairs/receivers return nil", "wasm_evidence": "numeric, boolean, bitwise, shift, membership, and hinted dict/array/class-field/class-method/local string/bool/nil/array/dict/function concatenation/equality lower through i32/string/Value helpers, including string + direct function-call-returned mixed collection stringification; AST numeric arithmetic/comparisons, bitwise/shift, ==/!=, and short-circuit and/or route exact numeric-index array and exact string-key dict dynamic-key value access through i32 arithmetic/bitwise/comparison, WAT if(result i32), or tagged Value equality/truthiness without evaluating unused right operands; parser-lowered compound field/index assignments reuse BIN_OP read-modify-write expressions for WASM; constructor field hints handle conflicts inside class methods; runtime-selected + lowers through __sura_value_add, where number+number returns a tagged number, either string operand selects string concatenation, and unsupported tag combinations return tagged nil; static arrays concatenate through __sura_array_concat2. The 16-byte guarded Value record stores tag, payload, and metadata. Homogeneous raw arrays at dynamic-add sites use __sura_value_array_typed; general array Value wrapping, coalesce branches, and stored local arrays attach the tag when direct fixed-index or name[*] evidence proves it. A cycle-safe structural walk propagates direct element evidence through arbitrarily long array +, ??, ternary, slice, reverse, sort, unique, clone/copy, concat, repeat, and range producer chains without entering whole-function inference. __sura_value_add converts typed tag-4/tag-8 pairs through __sura_array_to_dynamic_values in either operand order, preserves same-metadata raw results, and converts different known raw element tags into a heterogeneous dynamic result. Genuinely unknown raw element storage remains conservative when mixed with tag-8 arrays because its cells cannot be tagged safely. Known-type inference has a conservative depth limit so long acyclic call graphs fall back to unknown/tagged lowering rather than overflowing the transpiler stack. Dynamic -, *, /, %, numeric comparison, and shift operands pass through __sura_value_require_num; division, modulo, and shift operations use guarded i32 helpers. Executable VM, JIT-entry, and WASM coverage includes mixed observed function parameters, method arguments, constructor-derived conflicting fields, mixed catch payloads, interpolation, typed static/dynamic array concatenation in both operand orders, raw array metadata preserved through a mixed array-or-bool function return and through a twelve-stage slice producer, catchable numeric type and arithmetic failures, invalid dynamic addition, and the full integration fixture without tagged Value double wrapping; the in operator now preserves VM membership semantics for strings, dictionaries, homogeneous raw arrays (including content-aware string arrays), tagged dynamic arrays, and runtime-selected receivers; unsupported receiver types return tagged nil. tests/wasm_membership_operator.sura and the full WASM target smoke execute the same true/false/nil cases in the VM, JIT entry path, and emitted WebAssembly; dynamic numeric type failures, division/modulo by zero, signed division overflow, invalid shift counts, and /= or %= failures now use the tagged exception side channel instead of uncaught WebAssembly traps. tests/wasm_dynamic_numeric_errors.sura executes the same catch flow in the VM, JIT entry path, and emitted WebAssembly, and failed in-place division/modulo leaves the target unchanged; fractional literals crossing a mixed-type function parameter/return boundary now use a tag-10 f64 payload inside the guarded 16-byte Value record. tests/wasm_dynamic_decimal_value.sura proves 1.5 and -2.25 round-trip with numeric equality, type, and truthiness parity in the VM, JIT entry path, and emitted WebAssembly. General arithmetic operators still use the portable i32 path; string concatenation now preserves string values read through function-call-derived known string keys on super.method-returned dict aliases without routing through numeric i32 stringification. Method-call-derived exact string-key reads also stay on the string concatenation path without numeric i32 stringification. Method-call-derived exact numeric-index reads also preserve string element concatenation without numeric i32 stringification. Capture analysis now constant-folds simple numeric binary expressions that depend only on primitive constants before lifting inline function expressions. Capture analysis now folds primitive null coalescing and bool-only and/or expressions that depend only on proven primitive constants. Null coalescing now lowers for optional string/handle access paths by evaluating the left side once, preserving non-nil handles, and using the fallback only for nil. Equality and inequality over mixed ternary collection index and dot accesses are now smoke-covered through __sura_value_index/__sura_value_field plus tagged Value equality. Numeric arithmetic and comparison over mixed ternary collection index and dot accesses now lower through __sura_value_index/__sura_value_field plus tagged Value numeric extraction. Numeric ternary branches containing mixed runtime collection index and dot accesses now lower branch-wise through tagged Value numeric extraction. Numeric null coalescing over mixed runtime collection index and dot accesses now lowers through tagged Value nil checks before numeric extraction. Null coalescing now uses tagged Value nil checks for value-context lowering, so false and 0 from optional field reads remain valid left-hand values instead of falling through to the fallback. Direct false ?? true and 0 ?? fallback expressions are smoke-covered in equality, interpolation, and call arguments, preserving falsy non-nil left values. Mixed-type null coalescing now participates in Value-expression lowering, including type(1 ?? string), to_str(1 ?? string), and nil ?? array fallbacks. Null coalescing smoke now verifies short-circuit evaluation with a side-effecting fallback function: non-nil left values skip the fallback, nil left values call it once.", "complete": false, "next_action": "extend tagged f64 numbers into general arithmetic, comparison, conversion, stringification, collection, and export paths, then finish remaining fully dynamic operator semantics" }, { "node": "UNARY_OP", "kind": "expr", "js_status": "full", "wasm_status": "full", "js_evidence": "JS unary operators are preserved", "wasm_evidence": "Sura\u0027s complete unary operator set is lowered in WASM: unary minus and bitwise-not lower to i32 arithmetic, including bitwise-not over exact numeric-index dynamic array access, while \not lowers through condition/value truthiness for numeric, string, bool, nil, array, dict, object, and function operands. Smoke coverage includes expression-valued array/dict literal truthiness, promoted function value truthiness, string/nil/indexed Value truthiness, and exact numeric-index array plus exact string-key dict dynamic-key value access.", "complete": true, "next_action": "none" }, { "node": "DOT_ACCESS", "kind": "expr", "js_status": "full", "wasm_status": "partial", "js_evidence": "JS property access is preserved", "wasm_evidence": "enum constants, dict-backed numeric fields, and hinted string/bool/nil/array/dict/function dict/class fields lower through __sura_dict_get plus Value/string helpers, including direct function-call-returned exact field mixed primitive dict type(value)/length(value)/to_bool(value)/to_str(value), updated function-valued field hints after object field assignment, object-valued dict/class field receiver hints, constructor-param-derived object class-field receiver hints including inherited super.init propagation, active same-class local object field hints, field type hints from object-returning receiver expressions, and conflict dropping for mixed observed field types Function-returned mixed Value aliases are smoke-covered through later field reads via __sura_value_field. Tagged Value field reads now accept both dynamic dict tag 9 and raw dict tag 5, matching the raw/dynamic support already required by Value index reads and setters. Exact dot reads from captured constant dict literal snapshots now fold into capturable primitive aliases before inline function-expression lifting. Dot writes on locals holding mixed runtime Value dictionaries now lower through a tagged Value field setter and avoid stale static field hints, so later dot reads stay on the dynamic Value path. Exact dot reads of dictionaries containing inline anonymous function expressions now keep function display/type hints after expression-tree promotion. Optional dot reads on nil receivers now return nil through a guarded __sura_dict_get path instead of trapping, including chained nil receiver reads. Mixed ternary collection receivers in Value contexts now lower dot reads through __sura_value_field, returning nil for non-dict receivers or missing fields instead of forcing raw dict_get lowering. Mixed collection receivers produced by null coalescing now lower dot access through tagged Value field lookup instead of assuming a single dict-backed payload shape. Nested mixed runtime access chains now keep subsequent dot access on the tagged Value field path, including nil-preserving missing-field chains. Same-type dict ternary receivers with divergent literal key or value-type shapes now lower field reads through tagged Value field lookup. Same-type dict null-coalescing receivers with divergent literal key or value-type shapes now lower field reads through tagged Value field lookup. Mixed runtime Value dot access assignments can now store the tagged Value result in locals without losing later type/string/length/truthiness semantics. Locals assigned from mixed array/dict/nil ternaries now keep tagged Value collection payloads, so later alias.field reads lower through __sura_value_field. Caller aliases assigned from method and super-method returned mixed dict Values now keep tagged Value payloads for later dot writes and reads instead of forcing a single raw dict shape.; exact dot reads from conditional method-returned constructor-field dictionaries now preserve key hints when the method condition is resolved from literal call arguments; exact dot reads from conditional function-returned dictionaries and aliases preserve key hints through literal argument branch resolution.", "complete": false, "next_action": "add general object/property lowering" }, { "node": "INDEX", "kind": "expr", "js_status": "full", "wasm_status": "partial", "js_evidence": "JS index access is preserved", "wasm_evidence": "numeric array indexing and hinted string/bool/nil/array/dict/function array or string-key dict/class/object-returning receiver element access lower through linear memory/dict lookup plus Value/string helpers, including nil-aware string indexing via __sura_string_at, homogeneous array element type hints for dynamic numeric indexes, exact numeric-index variable mixed primitive array type(value)/length(value)/to_bool(value)/to_str(value), direct function-call-returned exact numeric-index mixed primitive array type(value)/length(value)/to_bool(value)/to_str(value), method-call-derived exact numeric-index mixed primitive array type(value)/length(value)/to_bool(value)/to_str(value), exact string-key variable mixed primitive dict type(value)/length(value)/to_bool(value)/to_str(value), direct function-call-returned exact string-key mixed primitive dict type(value)/length(value)/to_bool(value)/to_str(value), object-valued array/string-key dict receiver hints, method-call-derived exact numeric-index object receiver hints after array assignment, same dynamic-index variable numeric/string/bool/nil value type and object receiver hints after array assignment, same-key dynamic string-key dict numeric/string/bool/nil/array/dict/function value type and object receiver hints after dict assignment, homogeneous object array/dict dynamic receiver hints, dynamic string-key dict lookup through runtime string hashing including string-typed key variables whose exact value is unavailable on super.method-returned dict aliases, object/function-valued dynamic key updates, updated index hints after assignment, and conflict dropping for mixed observed indexed element types Function-returned mixed Value aliases are smoke-covered through later numeric-index reads via __sura_value_index.; exact numeric-index and string-key reads from conditional method-returned constructor-field collections now preserve fixed element/key hints when the method condition is resolved from literal call arguments; exact reads from conditional function-returned collections and aliases preserve the same fixed element/key hints when literal call arguments resolve the return branch; exact string-key reads from inherited super.method-returned dictionaries now use dict lookup even when the key is a variable with a known string literal value. Function-call-derived known string keys such as dict[choose_key(true)] now resolve to exact dict keys, so post-write string reads preserve string hints instead of falling back to numeric string conversion. Method-call-derived known string keys such as dict[picker.pick(true)] now resolve to exact dict keys when the receiver class and literal return branch are known. Function- and method-call-derived known numeric indexes such as array[picker.pick_index(true)] now resolve literal return branches for exact array reads. Exact string-key and numeric-index reads now preserve key-expression call side effects before using the optimized key/index, so dict[make_key()] and array[make_index()] still execute global writes. Exact indexed array reads used by to_str(value) now execute effectful index expressions before fixed-index stringification. Exact indexed array reads used by type(value) and length(value) now have regression coverage for effectful index evaluation. Array and dict handles returned by runtime-selected function values now preserve indexed element and field access at the caller after indirect dispatch. Dict literals whose entries are all function values now preserve exact field function type hints, allowing runtime string-key lookups such as handlers[key] to feed callable function-value locals. Homogeneous function-valued dict lookups now feed two-argument function-value dispatch smoke coverage, proving dynamic string-key function reads preserve callable lift metadata beyond unary handlers. Homogeneous function-valued array lookups now feed two-argument function-value dispatch smoke coverage, proving dynamic numeric-index function reads preserve callable lift metadata beyond unary handlers. Exact reads from captured constant array/dict literal snapshots now fold into capturable primitive aliases before inline function-expression lifting. Exact indexed reads of arrays containing inline anonymous function expressions now keep function display/type hints after expression-tree promotion. Index writes on locals holding mixed runtime Value arrays or dictionaries now lower through tagged Value setter helpers instead of treating the Value cell as a raw array/dict pointer. Dict lookup lowering now shares the guarded __sura_dict_get path so nil dict receivers return nil instead of trapping. Static nil receiver indexed reads now lower directly to nil for numeric and string keys, including type(value) and to_str(value), instead of emitting a raw memory load that can trap. Mixed ternary collection receivers in Value contexts now lower through __sura_value_index, dispatching string, dynamic-array, and dynamic-dict indexing at runtime and returning nil for missing or out-of-range values. Mixed collection receivers produced by null coalescing now lower index access through tagged Value indexing instead of assuming a single array/dict/string payload shape. Nested mixed runtime access chains now keep subsequent index access on the tagged Value indexing path after a dynamic field read. Same-type array ternary receivers with divergent literal element types or lengths now lower index reads through tagged Value indexing. Same-type array null-coalescing receivers with divergent literal element types or lengths now lower index reads through tagged Value indexing. Mixed runtime Value index/dot access assignments can now store the tagged Value result in locals without collapsing to a raw numeric/string handle. Locals assigned from mixed array/dict/string/nil ternaries now keep tagged Value collection payloads, so later alias[index] reads lower through __sura_value_index. Caller aliases assigned from method and super-method returned mixed collection Values now keep tagged Value payloads for later indexed writes and reads instead of collapsing to raw array-pointer arithmetic. Indexed reads after WASM-lowered array.push(value) are smoke-covered, proving the copied array keeps previous elements and stores the appended value at the new tail index. Indexed reads from WASM-lowered string split arrays now retain string element hints, so split_parts[0] and split_module_parts[2] lower as string loads rather than numeric array reads. Dynamic array and dictionary lookups that select function values preserve lift candidates through local aliases, including later calls whose results are dict values or returned function values.", "complete": false, "next_action": "add general array/dict/string index lowering" }, { "node": "CALL", "kind": "expr", "js_status": "full", "wasm_status": "partial", "js_evidence": "JS call expressions are preserved", "wasm_evidence": "numeric calls, whitelisted intrinsics including string contains/indexOf/index_of/startsWith/endsWith search helpers, upper/lower/trim/replace transforms, and substring/slice helpers, primitive/collection/function type(value) runtime-name calls through __sura_value_type_name including promoted function values and nil-aware dynamic string indexes, length(value) for string/array/dict values through __sura_value_length, and primitive to_str(value) through __sura_value_to_string, exact numeric-index variable mixed primitive array type(value), direct function-call-returned exact numeric-index mixed primitive array type(value)/length(value)/to_bool(value)/to_str(value), method-call-derived exact numeric-index mixed primitive array type(value)/length(value)/to_bool(value)/to_str(value), direct function-call-returned exact string-key/field mixed primitive dict type(value)/length(value)/to_bool(value)/to_str(value), exact string-key variable mixed primitive dict type(value), and branch-sensitive mixed ternary type(value), exact numeric-index variable mixed primitive string element length(value), exact string-key variable mixed primitive dict string element length(value), branch-sensitive mixed ternary length(value) for string/array/dict values, primitive to_str(value) for static/hinted string/bool/nil/num values plus directly named promoted functions, exact function aliases, visible array/dict literals, same-branch-visible ternary literals, homogeneous numeric/string/bool/nil array variables, fixed-index mixed primitive array variables, direct function-call-returned fixed-index mixed primitive array to_str(value), fixed-key mixed primitive dict variables, direct function-call-returned fixed-key mixed primitive dict to_str(value), exact numeric-index variable mixed primitive array element to_str(value), exact string-key variable mixed primitive dict element to_str(value), exact array/dict function lookup to_str(function), exact string-key variable function lookup to_str(function), exact numeric-index variable function lookup to_str(function), nested array/dict variables inside literal to_str(value), and branch-sensitive mixed ternary to_str(value) with top-level string semantics, value-aware to_bool(value) including promoted function values, exact numeric-index variable mixed primitive bool elements, and exact string-key variable mixed primitive dict bool elements, observed typed function-argument calls including function-valued arguments, object-typed argument calls including field/index return hints, object-returning and function-returning function calls, context-param-derived nested function call return hints, same-arity function-value calls through dispatchers generated for every arity observed in the module, with executable coverage through twelve arguments, and same-type if/foreach/match-derived string/function return hints lower with string/bool/nil/num/array/dict/function parameter and return hints plus same-class object return hints including if-returned, foreach-returned, and wildcard-covered same-class match object returns, dropping hints when mixed call sites or mixed return branches conflict; direct function-call-returned array/dict collection values are smoke-covered for length(value) and to_bool(value) through __sura_value_length and __sura_value_is_truthy. Observed array/dict argument-returned collection values are smoke-covered for length(value) and to_bool(value) through the same Value helpers. Function-returned module-global string, array, and dict handles are smoke-covered across concat, index, and dot-access call sites. Module-global handles are smoke-covered through dynamic type(), length(), and to_bool() calls using the tagged Value helper ABI. Direct calls now propagate global assignment shape effects into subsequent caller statements, including dict field type hints for global dot access and primitive stringification. Direct calls in IF conditions now propagate global assignment shape effects before branch lowering continues, so later statements can reuse global dict field hints. Direct calls in loop setup expressions now propagate global assignment shape effects for while/repeat/for/foreach before later statements are lowered. Direct calls in match subjects now propagate global assignment shape effects before match-arm hint snapshots and later statement lowering. Direct calls in throw payload expressions now propagate global assignment shape effects before catch/post-try lowering continues. Direct calls in assignment keys and values now propagate global assignment shape effects before later statement lowering. Method-returned constructor-field array/dict values now preserve fixed-index and ordered-key hints for to_str(value) stringification, including conditional full-or-empty self-field returns and exact index/key reads from literal-true branches. Conditional function-returned arrays/dicts now stringify full-or-empty branches for to_str(value) and preserve exact index/key hints when literal call arguments resolve the return branch; call-site-observed collection shapes now seed function parameters so nested function-local aliases can keep those collection hints. New-expression constructor calls now seed constructor parameters with observed collection shapes, so constructor-local aliases of array/dict arguments can stringify and index through typed collection lowering. Function-call returned mixed collection Values are smoke-covered across caller-side type, length, index, dot, numeric coercion, and to_str lowering. Function calls whose bodies return mixed collection Values now keep the tagged Value ABI even when literal arguments identify one return branch, so caller aliases do not collapse to raw array/dict types. to_str(function-valued indexed lookups) now preserves effectful receiver/key evaluation before emitting the static function display string. to_str(exact indexed array elements) now preserves effectful index evaluation before using the optimized fixed element conversion. type(value) and length(value) over exact indexed array reads are smoke-covered with effectful index expressions, preserving the index call before optimized type/length lowering. to_str(function()/method()) over statically stringified empty collection returns now evaluates zero-argument calls before emitting the optimized collection string, preserving function/method body side effects. Argument-bearing function/method return stringification now pre-evaluates calls when the inferred return expression is non-effectful, preserving body side effects before optimized empty collection strings. Effectful function-returned non-empty array/dict stringification now materializes the returned collection once in a temporary local before formatting individual elements or keys. Catch variables receiving a single-target function throw payload can now lower err(args) to the recovered lifted WASM function instead of an unresolved catch-local call. Function call arguments that carry a single function target now flow into callee throw payload analysis for catch-side invocation. Calls returning literal numeric or string branches can now feed exact key/index lowering when arguments make the branch statically known. print(...), print_n(...), and print_no_nl(...) expression calls now reuse console-style multi-argument stringification for strings, bools, nil, arrays, and dicts instead of the former single numeric expression path. Direct calls through locals and aliases assigned from lifted non-capturing function expressions now lower to the generated WASM function target instead of an unresolved local-name call. Function alias lift hints now survive compatible if/repeat/match merges, so post-control-flow alias calls lower to the correct generated function target. Function-valued parameters with a single observed promoted/lifted function target now seed local function display/lift hints while compiling the callee, so handler(args) lowers to the lifted WASM function instead of an invalid call to the parameter name; unresolved or conflicted indirect calls fail explicitly instead of emitting invalid WAT. Function-valued object fields initialized from single-target constructor parameters now carry class-field lift hints into methods, so aliases such as picked is self.handler followed by picked(value) lower to the observed lifted WASM function instead of an invalid local-name call. Function-valued function/method returns now infer display/lift hints from simple return bodies, so assigning a returned function to a local alias and calling it lowers to the observed lifted WASM function. Function-valued returns selected by literal-resolved ternary branches now propagate the selected lifted target through local aliases before invocation. Function-valued returns selected by literal-resolved match arms now propagate the selected lifted target through local aliases before invocation. Function-valued parameters with multiple observed same-arity lifted targets now lower through generated WASM function-value dispatch helpers instead of failing when no single target hint is available. Function-valued parameters with multiple observed two-argument lifted targets are now smoke-covered through __sura_call_function_2, so callee-local handler(left, right) preserves arity and target dispatch metadata. Function-valued local aliases selected by runtime ternaries are now smoke-covered for zero-argument calls through __sura_call_function_0, proving indirect dispatch also handles handler() without argument stack fragments. Function-valued local aliases selected by runtime ternaries are now smoke-covered for two-argument calls through __sura_call_function_2, proving argument ordering and same-arity dispatch are not limited to unary handlers. Function-valued local aliases selected by runtime ternaries now lower through same-arity dispatch helpers, so local handler(args) calls work even when no single lifted target is statically selected. String-returning function values selected through runtime ternaries now dispatch through __sura_call_function_1 while preserving string return hints for direct equality and interpolation. Bool-, array-, nil-, dict-, and function-returning function values selected through runtime ternaries now dispatch through __sura_call_function_1 while preserving bool truthiness/equality, nil type/truthiness, array and dict length/index/field/to_str use, and returned function invocation at the caller. Function values read from homogeneous function-valued dictionaries through runtime string-key variables now retain function type hints and dispatch through same-arity helpers, so handler = handlers[key]; handler(arg) lowers without unreachable fallback. Function values read from homogeneous function-valued dictionaries through runtime string-key variables are now smoke-covered for two-argument calls as well, so handler = handlers[key]; handler(left, right) dispatches through __sura_call_function_2 without collapsing to an unresolved local call. Function values read from homogeneous function-valued arrays through runtime numeric-index variables are now smoke-covered for two-argument calls, so handler = handlers[index]; handler(left, right) dispatches through __sura_call_function_2 without unreachable fallback. Function-valued foreach loop variables over homogeneous function arrays are now smoke-covered for two-argument dispatch, preserving loop-variable function metadata through handler(left, right). Indirect function-value calls emitted from source and AST lowering now preserve WAT instruction boundaries for receiver id loads, argument evaluation, and __sura_call_function_N dispatch instead of concatenating command fragments. Immediately-called inline function-expression wrappers now inline in the current WASM scope when their body calls a runtime-selected function local, so wrapper(value) can dispatch through __sura_call_function_N instead of emitting an invalid call to the captured local name. Function Values returned from inline function-expression returns are smoke-covered through later local calls using the existing lifted function-value call path. Local aliases assigned from literal-resolved super.method() function returns are smoke-covered through later direct invocation. Function Values produced from primitive constant-capturing inline functions are smoke-covered through direct local calls after assignment and return. Pure type(value), length(value)/len(value), and to_bool(value) calls over captured primitive or constant collection snapshots now fold into capturable constants before inline function-expression lifting. Pure to_str(value) calls over captured primitive or constant collection snapshots now fold into capturable strings before inline function-expression lifting. Pure numeric calls over captured constants now fold before inline function-expression lifting, including min/max/pow/sqrt/clamp/round-style variants. Pure array module calls over captured numeric array constants now fold before inline function-expression lifting, including sum/avg/min/max/index_of/contains variants. Pure array.range/array_range calls over captured numeric bounds now fold into captured numeric array snapshots before inline function-expression lifting. Array module calls now expose WASM return-type hints for range, len/sum/avg/min/max/index, and contains aliases, so array.range results flow through type(), length(), to_bool(), to_str(), and receiver method calls after assignment. Pure string module/function calls over captured constants now fold before inline function-expression lifting, including transform/search/replace/slice variants. type(value), length(value), to_bool(value), and to_str(value) now have smoke coverage for optional-access null coalescing results, including string fallbacks and collection fallbacks. length(value) and to_bool(value) now have smoke coverage for mixed ternary collection index and dot accesses through __sura_value_index/__sura_value_field plus Value length/truthiness helpers. Global and string-module string calls on mixed runtime Value index/dot accesses now stringify through tagged Value helpers before lowering to upper/lower/trim/replace/contains/indexOf/substring helper calls. Locals assigned from mixed runtime Value index/dot accesses now preserve the tagged Value ABI through later type(value), length(value), to_bool(value), to_str(value), equality, string concatenation, and numeric coercion call sites. array.len/length/size/sum/avg/min/max/contains/index_of module calls on mixed runtime Value collection aliases now lower through tagged Value array helpers instead of raw array-pointer helpers. Direct array_len/array_length/array_size/array_sum/array_avg/array_average/array_min/array_max/array_contains/array_includes/array_index_of/array_index/array_indexOf aliases on mixed runtime Value collection aliases now lower through the same tagged Value array helper path. Direct string_contains/string_indexOf/string_index_of/string_startsWith/string_starts_with/string_endsWith/string_ends_with aliases on source and AST mixed runtime or hinted string accesses now lower to string search helpers instead of unresolved function calls, matching native and JS direct-alias parity. Direct string_upper/string_lower/string_trim/string_replace/string_substring/string_slice/string_sub aliases now share the same WASM string transform/slice helpers as global, module, and receiver forms, with native and JS direct-alias parity. Direct string_len/string_length/string_size and string.length/string.size module aliases now lower through the same WASM length helper path as length/len and expose matching native and JS aliases. Direct string_repeat(text, count) and module string.repeat(text, count) now lower through __sura_string_repeat, preserving native/JS string repeat API parity for static and hinted string values. Direct string_pad_left/string_pad_right and module string.pad_left/string.pad_right calls now lower through __sura_string_pad_left/__sura_string_pad_right for static and hinted string values, covering default space fill and single-character fill paths without unresolved calls. Direct string_lines(text) and module string.lines(text) now lower through __sura_string_lines for static and hinted strings, returning string arrays whose element hints feed len(), indexing, join(), and interpolation paths. Direct string_words(text) and module string.words(text) now lower through __sura_string_words for static and hinted strings, splitting ASCII whitespace into string arrays whose element hints feed len(), indexing, join(), and interpolation paths. Direct text_chunks/text_chunk and module string.chunks(text, max_chars?, overlap?) now lower through __sura_text_chunks for static and hinted strings, producing string arrays with overlap-aware chunks whose element hints feed len(), indexing, join(), and interpolation paths. Pure direct string_indexOf/string_startsWith/string_endsWith aliases over captured string constants now fold before inline function-expression lifting and keep return type hints. Global and string-module string calls on locals assigned from mixed runtime Value index/dot accesses now stringify through the tagged Value ABI before string helper lowering. Mixed collection Value aliases are smoke-covered through later type(value), length(value), to_str(alias[index]), string helper calls, and numeric field coercion. dict.has(dict, key) and dict.contains(dict, key) module calls now lower to __sura_dict_has, extending standard dictionary API coverage beyond len and direct indexing. Direct array_repeat(value, count) and module array.repeat(value, count) now lower through __sura_array_repeat, allocate raw arrays of the requested length, preserve repeated element type hints for numeric/string/bool joins, and produce empty arrays for zero counts. Direct array_unique(array) now lowers through __sura_array_unique for homogeneous numeric arrays, preserving first-seen order and numeric element hints for later join() and interpolation. Direct set_union(array, ...) calls now lower through folded __sura_array_concat2 plus __sura_array_unique, preserving first-seen order and homogeneous numeric element hints for later join()/interpolation. Direct set_intersection(array, ...) and set_difference(array, ...) calls now lower through raw-array set helpers that reuse __sura_array_contains and preserve unique first-seen numeric output plus element hints for later join()/interpolation. Direct set_symmetric_difference(array, array), set_is_subset(array, array), and set_is_superset(array, array) now lower through raw-array symmetric-difference/subset helpers, preserving unique first-seen numeric output and boolean subset/superset results. Direct array_flatten(array_of_arrays) and module array.flatten(array_of_arrays) now lower through __sura_array_flatten1 for one-level raw array-of-arrays values, preserving nested homogeneous element hints for later join()/interpolation. Mixed observed function parameters use the tagged Value ABI. When a known ordered raw dictionary is passed to such a parameter, only that call argument is reconstructed as a tag-9 dynamic dictionary so recursive stringification preserves its keys and values without expanding the conversion cost across unrelated Value operations. Direct calls to non-escaping inline function-expression locals with runtime parameter captures now inline inside the owner function before normal call lowering, while escaped closure calls without a valid lift target fail explicitly instead of producing invalid WAT. Calls through function values produced by direct return-factory calls such as adder = make_adder(7); adder(5) now lower with the captured argument substituted into a specialized lifted function target. Calls through returned closures that capture function-valued factory arguments are smoke-covered in both normal source and embedded AST fixtures, proving the specialized closure body calls the resolved lifted target instead of unresolved handler or unreachable fallback code. Function-value calls produced by pure local-alias closure factories now dispatch to the specialized lifted WASM target instead of falling through to unreachable indirect-call lowering. Function-value calls produced by pure if-branch closure factories now lower through the specialized lifted dispatch target instead of the generic unreachable fallback. Function-value calls produced by false-no-else if closure factories now lower through the specialized lifted target without dropping reachable pre-if captures. Function-value calls produced by unknown-if-without-else closure factories now lower through the specialized lifted target when the returned closure only depends on captures common to both paths. Function-value calls produced by pure match-arm closure factories now lower through the specialized lifted dispatch target instead of the generic unreachable fallback. Function-value calls produced by no-arm static match closure factories now lower through the specialized lifted target without dropping reachable pre-match captures. Function-value calls produced by bounded exact repeat closure factories now lower through the specialized lifted target with the repeated assignment captured instead of using a stale initial local value. Function-value calls produced by bounded static range-for closure factories now lower through the specialized lifted target with the loop-accumulated assignment captured. Function-value calls produced by zero-iteration static range-for closure factories now lower through the specialized lifted target with only reachable pre-loop captures. Function-value calls produced by static foreach closure factories now lower through the specialized lifted target with literal collection iteration effects captured. Function-value calls produced by empty array and empty dict static foreach closure factories now lower through the specialized lifted target with only reachable pre-loop captures. Function-value calls produced by captured-false while closure factories now lower through the specialized lifted target without stale or unreachable loop-body assignments. Function-value calls produced by literal-false while closure factories now lower through the specialized lifted target with only the reachable pre-loop captures. Lookup-selected function values from function-valued arrays and dictionaries now preserve dict-returning and function-returning dispatch results; returned function values can be stored in caller locals and invoked later through __sura_call_function_N instead of falling through to unreachable.", "complete": false, "next_action": "lower general calls through bytecode or a Value ABI" }, { "node": "METHOD_CALL", "kind": "expr", "js_status": "full", "wasm_status": "partial", "js_evidence": "JS method calls are preserved", "wasm_evidence": "array len, string.contains/string.indexOf/string.index_of/string.starts_with/string.ends_with/string.upper/string.lower/string.trim/string.replace/string.substring/string.slice/string.sub module aliases, string receiver contains/indexOf/index_of/starts_with/ends_with/upper/lower/trim/replace/substring/slice/sub methods, selected intrinsic aliases, and hinted dict-backed numeric/value class methods lower to generated WASM functions with inherited lookup plus class-level, instance-specific, active same-class local object, function-local new object, if/match-merged local object, array/dict-stored object receiver, constructor-param-derived object class-field receiver including inherited super.init propagation, homogeneous dynamic array/dict object receiver, dynamic string-key dict-assigned object receiver including same-key exact mixed-dict updates, same-variable dynamic array-index-assigned object receiver, method-call-derived numeric-index-assigned object receiver, foreach-returned object call receiver, object-typed method argument, object-param-derived method/field/index return hints, object-returning call, and non-IDENT object receiver hints, including bool-returning self-field logic, self-field array/dict/function ternary returns, context-param-derived local-object method string returns, and function-valued class field method returns/truthiness/equality; method bodies can use non-conflicting observed self-field and method-argument hints for string/bool/nil/array/dict/function concatenation/truthiness, dropping method-argument hints when mixed call sites conflict and guarding recursive method return inference; constructor-field array/dict hints now flow through direct method returns, so to_str(obj.items_value()) and to_str(obj.profile_value()) lower through typed array/dict stringification; branch-sensitive method return lowering resolves self-field ternaries such as to_str(obj.pick_items(flag)) and local aliases of those ternaries, while exact reads such as obj.pick_items(true)[0], obj.pick_profile(true).score, and obj.pick_profile(true)[key] preserve element/key type hints; child methods that return super.method(...) collection values now resolve those inherited returns for caller-side to_str(method()) and exact string-key access, including key variables with known string literal values. Direct method calls now propagate global assignment shape effects into subsequent caller statements, including dict field type hints for global dot access and primitive stringification. Zero-argument method-return collection stringification now evaluates the method once before using inferred empty collection string output. Argument-bearing method-return collection stringification now evaluates the method once before inferred empty collection string output when the resolved return expression has no side effects. Effectful method-returned non-empty array/dict stringification now materializes the returned collection once before formatting, preventing repeated method side effects.; method calls returning literal-branch strings can now feed exact dict-key lowering for writes and later reads. Method calls returning literal numeric branches can now feed exact array-index lowering for writes and later reads. Methods can now invoke a function-valued self field through a local alias when constructor call sites observe a single promoted/lifted function target. Method calls returning a function-valued self field now preserve the returned function target for later local alias invocation. Method returns selected by literal-resolved ternary branches now propagate the selected function-valued self-field target through local aliases before invocation. Method returns selected by literal-resolved match arms now propagate the selected function-valued self-field target through local aliases before invocation. Function-valued self fields with multiple observed same-arity constructor targets now invoke through the WASM function-value dispatcher from method-local aliases, direct method returns, literal-resolved ternary returns, and literal-resolved match returns. Two-argument function-valued self fields and method-returned aliases are now smoke-covered through __sura_call_function_2, including method-local picked aliases and choose_handler(false) results. Method-local homogeneous function-valued dict lookups are now smoke-covered for two-argument dispatch, so handlers[key] inside a method can feed __sura_call_function_2 without unreachable fallback. Child methods can return or locally alias a super.method() function Value and call it with the recovered lifted target. Child methods can invoke two-argument function Values recovered from super.method(...) through the same function-value dispatcher used for ordinary method-returned aliases. Observed constructor self-field collection hints are now visible inside method return-type inference, so a method returning self.items can feed a parent super.method(...) return and later length(...) lowering. array.range module-method calls now propagate array type and fixed numeric element hints through assignments and direct expression use, enabling later length(), to_str(), contains(), index_of(), and foreach lowering without falling back to unresolved dynamic calls. Numeric array receiver methods now lower directly and pure captured constants fold before inline function-expression lifting. Pure string receiver methods over captured constants now fold before inline function-expression lifting, including trim/upper/lower/search/replace/substring/slice variants. String receiver methods on mixed runtime Value index/dot accesses now stringify through tagged Value helpers before lowering to trim/upper/contains/indexOf string helper calls. Chained string receiver methods on mixed runtime Value accesses now preserve method return type hints through replace/substring/slice transforms and follow-up string methods. len()/length() receiver methods on mixed runtime Value index/dot accesses now lower through tagged Value length helpers for strings, arrays, dicts, and nil. String receiver methods and len()/length() on locals assigned from mixed runtime Value index/dot accesses now lower through tagged Value stringification/length helpers. Value receiver contains()/index_of() methods now lower through a tagged runtime helper that preserves string search semantics and dispatches array Values through dynamic-array Value equality. Value receiver len()/length()/size() and sum()/avg()/min()/max() methods now lower through tagged array length/aggregate helpers for raw numeric arrays and dynamic Value arrays. Method bodies returning branch-sensitive mixed collection Values now preserve the tagged Value ABI at caller aliases, so later index/dot mutation and reads lower through __sura_value_set_index, __sura_value_set_field, __sura_value_index, and __sura_value_field. Dictionary receiver has/contains methods now lower through key-existence checks instead of value reads, preserving true for keys whose value is nil; dynamic Value dict receivers route has(...) and contains(...) through __sura_value_receiver_has/__sura_value_receiver_contains. Mixed-class ternary receivers now preserve class identity in an out-of-band object registry and lower same-name, same-arity calls through generated runtime class dispatchers. Executable smoke coverage verifies an overridden method on two runtime-selected classes plus an inherited parent method on a runtime-selected child without adding hidden keys to the user-visible dict-backed object. General local/parameter class-union dispatch remains outside this bounded path. Array receiver push(value) expression statements now lower by allocating a copied array with one appended slot and storing it back to the receiver local via __sura_array_push, so later len() and indexed reads see the appended value. Homogeneous array receiver join(separator) methods now lower for num/string/bool/nil arrays through __sura_array_join_* helpers, preserving separator insertion, raw string elements, and canonical true/false/nil text without falling back to unresolved dynamic calls. String receiver split(separator) and string.split(value, separator) module calls now lower to __sura_string_split, producing string arrays with element hints preserved for len(), indexing, join(), and interpolation. String receiver repeat(count) now lowers through __sura_string_repeat, so repeated string results can feed interpolation, concatenation, and later string methods without unresolved dynamic dispatch. String receiver pad_left(width, fill?) and pad_right(width, fill?) now lower through __sura_string_pad_left/__sura_string_pad_right, preserving padded string handles for interpolation, concatenation, and later string operations in the single-character fill and default-fill cases. String receiver lines() now lowers through __sura_string_lines, preserving the returned string-array element hints through later len(), indexed reads, join(), and interpolation. String receiver words() now lowers through __sura_string_words, preserving the returned string-array element hints through later len(), indexed reads, join(), and interpolation. String receiver chunks(max_chars?, overlap?) now lowers through __sura_text_chunks, preserving overlap-aware string-array element hints through later len(), indexed reads, join(), and interpolation. Homogeneous array receiver slice(start, end?) and array.slice(array, start, end?) module calls now lower through __sura_array_slice with negative-index normalization and element type hints preserved for later join(), indexing, and interpolation. Homogeneous array receiver pop() and array.pop(array) module calls now lower through __sura_array_pop, returning the removed tail value while updating the raw array length for later len() reads and preserving element type hints for interpolation. Homogeneous array receiver reverse() and array.reverse(array) module calls now lower through __sura_array_reverse, mutating raw arrays in place, returning the same array pointer for chaining, and preserving element type hints for later join() and interpolation. Homogeneous array receiver clear() and array.clear(array) calls now lower through __sura_array_clear, zeroing the raw array length, returning nil, and preserving later len() reads without stale tail values. Homogeneous array receiver insert(index, value) statements now lower through __sura_array_insert with local receiver pointer refresh, while array remove(index) receiver/module calls lower through __sura_array_remove with negative-index normalization, nil out-of-range returns, tail shifting, and element type hints preserved for the removed value. Homogeneous numeric array receiver sort() and array.sort(array) module calls now lower through __sura_array_sort, mutating arrays in ascending order, returning the same array pointer for chaining, and preserving numeric element hints for later join() and interpolation. Homogeneous numeric array.unique(array) module calls and receiver unique() calls now lower through __sura_array_unique, preserving first-seen order and returning a new raw array with duplicate numeric cells removed. Homogeneous array.clone(array) and array.copy(array) module calls now lower through __sura_array_clone, allocate an independent raw array copy, and preserve element hints so mutating the clone does not change the source before later join()/interpolation. Homogeneous array.concat(array, array, ...) module calls now lower through __sura_array_concat2 folds, allocate independent raw array results, preserve common element hints, and smoke coverage mutates the concatenated result to prove source arrays remain unchanged before later join()/interpolation. set.union(array, ...) module calls now lower through the same concat-plus-unique WASM path, extending array-backed set helper coverage without falling back to unresolved dynamic module calls. set.intersection(array, ...) and set.difference(array, ...) module calls now lower through __sura_array_intersection2/__sura_array_difference2 folds, extending array-backed set module coverage beyond union. set.symmetric_difference(...), set.symdiff(...), set.is_subset(...), set.subset(...), set.is_superset(...), and set.superset(...) module calls now lower through the same WASM helper path, completing array-backed set helper aliases currently exposed by the JS and native module maps. Homogeneous array.chunk(array, size) module calls now lower through __sura_array_chunk, allocate an outer raw array of chunk arrays, preserve outer array element hints, and smoke coverage verifies chunk count, per-chunk lengths, numeric element reads, and empty-array chunking. Homogeneous two-array array.zip(left, right) module calls now lower through __sura_array_zip2, allocate row arrays up to the shortest input length, preserve outer array element hints, and smoke coverage verifies row count, row lengths, numeric row element reads, and empty-result zip behavior. Homogeneous nested array receiver flatten() calls now lower through __sura_array_flatten1, with smoke coverage flattening array.chunk and array.zip results plus nested array literals without falling back to unresolved dynamic calls. Dictionary keys()/values()/items() receiver calls plus dict.keys(dict), dict.values(dict), dict.items(dict), dict_keys(dict), dict_values(dict), and dict_items(dict) module/direct calls now lower through __sura_dict_keys, __sura_dict_values, and __sura_dict_items, reusing stored key strings, preserving homogeneous value element hints for later join()/interpolation, and exposing item rows as two-cell arrays. Dictionary pick(keys) receiver calls plus dict.pick(dict, keys) and dict_pick(dict, keys) module/direct calls now lower through __sura_dict_pick, preserve selected-key ordering, skip missing keys, suppress duplicate key requests, and seed picked-dict field hints for exact follow-up dot/index reads. Dictionary omit(keys) receiver calls plus dict.omit(dict, keys) and dict_omit(dict, keys) module/direct calls now lower through __sura_dict_omit, preserve source key order while excluding requested keys, ignore missing/duplicate omitted keys, and seed omitted-dict field hints for exact follow-up dot/index reads. Dictionary merge(...) receiver calls plus dict.merge(...) and dict_merge(...) module/direct calls now lower through folded __sura_dict_merge2 helpers, copy input dictionaries into a new result, preserve first-seen key order, overwrite duplicate-key values from later dictionaries, and seed merged-dict field hints for exact follow-up dot/index reads. Dictionary get_path(path) receiver calls plus dict.get_path(dict, path) and dict_get_path(dict, path) module/direct calls lower literal dot paths to chained __sura_dict_get operations, preserve nil for missing nested fields, and carry static result hints for exact numeric/string follow-up uses. JSON path aliases json.path(dict, path), json.get_path(dict, path), json_path(dict, path), json.has_path(dict, path), and json_has_path(dict, path) now lower the same literal dot paths to chained __sura_dict_get/__sura_dict_has operations with bool existence results for the final key. Class methods with local function-valued dictionary and array lookups are smoke-covered when selected handlers return dictionaries or further function values, preserving caller-side length, field, to_str, type, truthiness, and later returned-function invocation.", "complete": false, "next_action": "add general method dispatch lowering" }, { "node": "SUPER_CALL", "kind": "expr", "js_status": "full", "wasm_status": "partial", "js_evidence": "super.init lowers to JS super(...)", "wasm_evidence": "AST super.init inside inherited numeric class constructors lowers to parent dict-backed constructor calls while inherited constructor object arguments propagate class-field receiver hints, and AST super.method(...) inside class methods lowers to the parent generated method function with self plus typed numeric/string/function return hints, including parent methods that return promoted function values from constructor-derived fields, current local/param arg-derived string returns, and method-local try/catch blocks that catch super-thrown string/function payloads; super.init(...) now propagates new-expression-observed collection argument shapes into parent constructor parameters, so inherited constructor-local array/dict aliases can stringify and perform exact key reads; super.method(...) now propagates call-site-observed collection argument shapes into parent method parameters, so parent method local array/dict aliases can stringify and perform exact key reads, and super.method-returned array/dict values can flow back through a child method return to caller-side to_str(value) and exact key reads, including known-string key variables without falling back to array indexing. super.init() parent constructor global assignment effects now flow through child new-expression lowering, so caller-side type(global), global.field, and to_str(global.field) keep the parent constructor\u0027s dict shape hints. Super-method function-valued throw payloads are smoke-covered through catch-side invocation, preserving the inherited lifted target across the exception bridge. Super-method calls that return function Values now propagate display/lift hints into local aliases, including parent methods that directly return inline non-capturing function expressions. Literal-resolved super.method(flag) calls now inspect the parent method return expression before body-wide fallback, so selected inline function branches keep their lifted target. Two-argument function Values returned from super.method(...) are now smoke-covered through local alias invocation and child-method-local invocation, preserving parent dispatch before __sura_call_function_2. Interpolation parser lowering now recognizes super.method(...) inside string expressions as SUPER_CALL rather than a normal method on an identifier named super, and super return-type inference carries object-typed child method arguments into the parent method body; smoke covers type(super.forwarded_label(box)) where the parent dispatch returns an object-parameter-derived string and length(super.forwarded_values(bag)) where the parent dispatch returns an object-parameter-derived array. Super-method return paths that forward branch-sensitive mixed collection Values now preserve the tagged Value ABI through child method aliases, including later index/dot mutation and readback.", "complete": false, "next_action": "extend remaining super dispatch over the full dynamic Value runtime" }, { "node": "ARRAY_LIT", "kind": "expr", "js_status": "full", "wasm_status": "full", "js_evidence": "JS array literals are preserved", "wasm_evidence": "numeric arrays lower to linear memory; primitive array literals lower into tagged dynamic Value arrays for direct type(value), length(value), to_bool(value), to_str(value), print, interpolation, concatenation, and recursive collection stringification through __sura_value_dynamic_array; smoke covers non-empty and empty array literal truthiness, mixed primitive arrays, nested arrays, function-valued elements, assignment-fed Value truthiness, homogeneous numeric/string/bool/nil/function element hints, fixed-index mixed primitive reads, direct function-call-returned arrays, object-valued entries for method receiver hints, foreach iteration, and conflict-safe hint propagation; constructor-passed array literals and array variables keep fixed-index hints through constructor-local aliases, inherited super.init parent constructor aliases, inherited super.method parent method aliases and method-returned collection flows, self fields, direct method returns, conditional full-or-empty method returns, conditional function returns, function-returned aliases, and call-site-observed function parameters for to_str(value). Function-returned indexed arrays used by to_str(value) now reuse one evaluated collection handle across element formatting instead of re-running the collection expression per element. Constant array literal snapshots can be substituted into lifted inline function bodies for read-only indexed use. Inline anonymous function-expression elements in array literals are lifted before lowering, preserving function type, truthiness, and display string hints for exact indexed reads.", "complete": true, "next_action": "none" }, { "node": "DICT_LIT", "kind": "expr", "js_status": "full", "wasm_status": "full", "js_evidence": "JS object literals are preserved", "wasm_evidence": "AST dict literals lower to hash/key/value tables with dot, literal string-key lookup, dynamic string-key lookup, and dynamic string-key updates through __sura_dict_get/__sura_dict_set plus runtime string hashing; primitive dict literals lower into tagged dynamic Value dicts for direct type(value), length(value), to_bool(value), to_str(value), print, interpolation, concatenation, and recursive collection stringification through __sura_value_dynamic_dict; smoke covers non-empty and empty dict literal truthiness, mixed primitive dictionaries, nested dict/array values, function-valued entries, assignment-fed Value truthiness, fixed-key mixed primitive reads, direct function-call-returned dictionaries, object-valued entries for dot/string-key/dynamic-key method receiver hints, foreach key/value iteration, and conflict-safe hint propagation; constructor-passed ordered dict literals and dict variables keep ordered-key and empty-dict hints through constructor-local aliases, inherited super.init parent constructor aliases, inherited super.method parent method aliases and method-returned collection flows, self fields, direct method returns, conditional full-or-empty method returns, conditional function returns, function-returned aliases, and call-site-observed function parameters for to_str(value). Method-returned ordered dictionaries used by to_str(value) now reuse one evaluated collection handle across key formatting instead of re-running the collection expression per key. Constant dict literal snapshots can be substituted into lifted inline function bodies for read-only dot/string-key use. Inline anonymous function-expression values in dict literals are lifted before lowering, preserving function type, truthiness, and display string hints for exact field reads.", "complete": true, "next_action": "none" }, { "node": "NEW_EXPR", "kind": "expr", "js_status": "full", "wasm_status": "partial", "js_evidence": "JS new expressions are preserved", "wasm_evidence": "AST dict-backed class construction lowers generated constructors and propagates literal plus constructor-argument class field type and object receiver hints to instances, including super.init-inherited constructor object arguments, dropping observed class-field hints when mixed constructor sites conflict; active local same-class new-expression ternaries plus function-local, if/match-merged, same-class if-returned, and wildcard-covered match-returned new object flows feed method dispatch, field value hints, and return hints; constructor arguments are now observed like calls, seeding generated constructor parameters with fixed-index array and ordered-key dict hints for constructor-local alias stringification and exact key reads. Constructor init bodies now propagate global assignment shape effects into subsequent caller statements, including dict field type hints for global dot access and primitive stringification after new Class().", "complete": false, "next_action": "extend object allocation, inheritance, and constructor dispatch to the full dynamic Value runtime" }, { "node": "SuraBlock", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "top-level source lines lower into JS", "wasm_evidence": "top-level Sura source and AST JSON input lower through the WASM AST JSON frontend into WAT main", "complete": true, "next_action": "none" }, { "node": "ASSIGN", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "is assignments lower to var/assignment", "wasm_evidence": "WASM assignments lower by converting any supported RHS expression to the target i32/handle representation and storing through local/global name storage; smoke covers reassignment plus string, bool, nil, array, dict, and function-value assignment, with dynamic type(value), to_bool(value), to_str(value), collection truthiness, and local hint propagation for later method/field/index dispatch, Value equality, and returns; aliases assigned from argument-resolved function-returned arrays/dicts now retain full/empty collection hints, ordered dict key/type hints, and fixed-index hints for later stringification and access, including local aliases inside functions, constructors, super.init parent constructors, and super.method parent methods whose parameters inherit call-site/new-expression-observed collection shapes. In-place reassignment now refreshes local type state after numeric and string mutation so later dynamic lowering does not reuse stale object/function/collection hints.", "complete": true, "next_action": "none" }, { "node": "IN_PLACE", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "in-place operators lower to JS compound assignments", "wasm_evidence": "numeric +=, -=, *=, /=, and %= compound assignments lower for local variables; string local += lowers through __sura_string_concat with updated local string hints; parser-lowered numeric/string field, fixed-index array, and dynamic-key dict compound assignments lower in WASM as DOT_ASSIGN/INDEX_ASSIGN read-modify-write target updates, including source and AST JSON smoke evidence for numeric array stores, dict field updates, dynamic string-key dict updates, and string field/index/dynamic-key concatenation Numeric -=, *=, /=, and %= in-place assignments now have AST smoke coverage and refresh the target value hint to number while clearing stale object/function/indexed/collection hints.", "complete": true, "next_action": "none" }, { "node": "DOT_ASSIGN", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "field assignment lowers to JS property assignment", "wasm_evidence": "AST numeric dict field assignment lowers existing-key updates through __sura_dict_set and records string/bool/nil/num/array/dict/function hints for later Value truthiness, equality, type checks, or concatenation, dropping the hint when mixed observed field types conflict; parser-lowered obj.field += numeric and string values lower as read-modify-write field assignment in WASM smoke evidence; source field assignment smoke coverage writes string/bool/nil/array/dict/function values through __sura_dict_set and preserves later type(value), length(value), to_bool(value), and to_str(value) results through tagged Value helpers or static hinted string lowering; embedded AST JSON smoke mirrors string/bool/nil/num/array/dict field assignment coverage Function-returned mixed Value aliases are smoke-covered through later field writes via __sura_value_set_field, including setter support for dynamic and raw dict Value tags. Function/method/constructor writes to fields on declared globals now propagate caller-side access type hints, so later global.field and to_str(global.field) lower through dict helpers with the updated type. Field-assignment value expressions now apply call side effects before later lowering, so dict.field is init_global() preserves global dict field hints.", "complete": true, "next_action": "none" }, { "node": "INDEX_ASSIGN", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "index assignment lowers to JS assignment", "wasm_evidence": "numeric array stores lower to i32.store; dynamic string-key dict updates lower through runtime string hashing; known-string key variables and string-typed dynamic key variables on dict aliases without a direct dict type hint, including super.method-returned dictionaries, lower through __sura_dict_set instead of array-store fallback; dynamic string-key dict updates now feed wildcard hints plus same-key exact num/string/bool/nil/array/dict/function value and object receiver hints for later arithmetic, equality, truthiness, concatenation, interpolation, and method/field/index dispatch; same-variable dynamic numeric array updates, including indexes whose numeric value is returned by a literal-resolved function or method call, feed num/string/bool/nil/array/dict/function type hints plus object receiver hints for later arithmetic, equality, truthiness, concatenation, interpolation, and method/field/index dispatch, numeric index assignments with literals feed WASM AST type hints while dropping stale hints when observed indexed element types conflict, and parser-lowered arr[i] += value / dict[key] += value lower as numeric and string read-modify-write index assignments in WASM smoke evidence; source smoke covers string/bool/nil/array/dict/function numeric-index assignments, dynamic string-key dict __sura_dict_set writes, and later Value truthiness/type/length helpers for indexed array reads Function-returned mixed Value aliases are smoke-covered through later numeric-index writes via __sura_value_set_index, including setter support for both dynamic and raw array/dict Value tags. Function-call-derived known string-key writes now update exact access hints after the write, including overwriting earlier numeric dict literal hints for the same key. Method-call-derived known string-key writes now update exact access hints after the write, including super.method-returned dict aliases. Function- and method-call-derived known numeric-index writes now update fixed array-index hints after the write. Function/method/constructor writes to exact indexes or known string keys on declared globals now propagate caller-side access hints, including mixed array element string reads after a global array index write. Index-assignment key and value expressions now apply call side effects before later lowering, including dynamic string-key calls and value calls that write globals.", "complete": true, "next_action": "none" }, { "node": "IF", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "if/elif/else lower to JS blocks", "wasm_evidence": "numeric if/elif/else, inline if/elif/else, branch-local declarations, and direct return branches lower to structured WAT if blocks; AST string/bool/nil/array/dict/function literal, assigned, and dynamic dict/index condition candidates route through tagged Value truthiness; then and else bodies cover dynamic Value operations for array type/length, dict truthiness, function type/truthiness/stringification, direct function-call-returned dict lookups, throw side effects, print lowering, and branch-local declarations; same-type branch returns and same-class branch-local object assignments feed function return hints while mixed branch returns or assignments drop the hint IF condition expressions now apply call side effects before branch hint snapshots, so global assignment shape effects from condition calls are visible to later WASM lowering. IF branch capture maps now merge only shared equal primitive constants for later inline function-expression lifting, avoiding stale captures after branch-local reassignment.", "complete": true, "next_action": "none" }, { "node": "WHILE", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "while lowers to JS loop", "wasm_evidence": "numeric while lowers to structured WAT loops with stable break/continue labels; string/bool/nil/array/dict/object/function condition candidates route through tagged Value truthiness; dynamic indexed numeric conditions are re-evaluated each iteration; loop bodies cover dynamic Value operations for array type/length, dict truthiness, function type/truthiness/stringification, normal numeric mutation, and break/continue; post-loop type/object/function/index hints conservatively merge loop-body hints with the pre-loop state so zero-iteration paths cannot poison later lowering While condition expressions now apply call side effects before loop-body hint snapshots, so zero-iteration condition calls can still update later global dict field lowering.", "complete": true, "next_action": "none" }, { "node": "REPEAT", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "repeat lowers to JS counted loop", "wasm_evidence": "repeat lowers to structured WAT loops with break/continue labels, snapshots arbitrary supported numeric count expressions before looping including indexed count reads, and conservatively merges loop-body type/object/function/index hints with the pre-loop state so repeat 0 paths cannot poison later lowering; smoke covers repeat bodies performing dynamic Value operations for array type/length, dict truthiness, function type/truthiness/stringification, and normal numeric mutation Repeat count expressions now apply call side effects before loop-body hint snapshots, so repeat 0 setup calls can still update later global dict field lowering.", "complete": true, "next_action": "none" }, { "node": "FOR", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "range for lowers to JS loop", "wasm_evidence": "numeric range for lowers to WAT loops with normal, reverse stepped, tilde, and dynamic indexed from/to/step expressions; range loops snapshot bounds/steps before looping, preserve break/continue labels, propagate numeric loop-variable hints into loop bodies, cover dynamic Value operations for array type/length, dict truthiness, function type/truthiness/stringification inside loop bodies, and conservatively merge loop-body type/object/function/index hints with the pre-loop state so zero-iteration ranges cannot poison later lowering For range bound/step expressions now apply call side effects before loop-body hint snapshots, so zero-iteration range setup calls can still update later global dict field lowering.", "complete": true, "next_action": "none" }, { "node": "FOREACH", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "foreach over arrays/dicts lowers through JS iter helpers", "wasm_evidence": "numeric array foreach lowers to linear-memory loop, AST foreach over homogeneous string/bool/nil/array/dict/function array literals or indexed array hints propagates element type hints into loop variables for string concatenation, truthiness, return hints, and value/indexed loops; homogeneous object array/dict foreach values propagate class receiver hints into loop variables for method dispatch and object-returning function-call receiver hints; AST for key, value in dict lowers over stored key strings plus hinted values including promoted function values while single-var dict iteration remains a no-op like the native runtime; source smoke covers string, bool, nil, array, dict, and function foreach loop values with later concatenation, truthiness, type, and length helpers; post-foreach type/object/function/index hints conservatively merge loop-body hints with the pre-loop state so empty array/dict iteration cannot poison later lowering Foreach collection expressions now apply call side effects before loop-body hint snapshots, so empty collection setup calls can still update later global dict field lowering.", "complete": true, "next_action": "none" }, { "node": "FUNC_DEF", "kind": "stmt", "js_status": "full", "wasm_status": "partial", "js_evidence": "function definitions lower to JS functions", "wasm_evidence": "numeric functions lower to exported WAT funcs, with observed string/bool/nil/num argument type hints plus same-type nested call, function-local new object method-call, if/match-merged local object method-call, if branch, foreach loop-variable, match-arm return hints, same-class if object return hints, homogeneous object foreach return hints, and wildcard-covered same-class match object return hints available while compiling AST function bodies; recursive function return inference is guarded; observed array/dict parameters returned from functions preserve collection type hints for caller-side Value length/truthiness, and observed fixed-index/ordered-key/empty collection argument shapes now seed function parameters while compiling function bodies. Function return type inference now preserves internal tagged Value returns when a body returns a mixed collection ternary or a local alias of that Value. Function-valued parameters are now used during throw payload function-target analysis, not only normal return/call lowering. Function return inference now has smoke coverage for string-returning function-value dispatch, so caller-side string operations keep the returned handle instead of treating it as a numeric result. Function return inference now also smoke-covers bool, array, nil, dict, and function returns from function-value dispatch, preserving primitive, collection, nil, and callable return handles across indirect calls. Observed function-valued parameters now carry display/lift hints into function body compilation, enabling direct invocation and to_str(function_param) for single-target function parameters. Observed two-argument function-valued parameters now carry enough metadata into function body compilation for multi-target dispatcher lowering, covering calls where add_pair_ast and mul_pair_ast are passed to the same callee. Function bodies now preserve primitive constant captures while discovering nested function-expression promotions, without treating mutable or collection captures as supported closures. Function return inference now tracks dynamic numeric-index function-valued array candidates as well as dynamic string-key dictionary candidates, so a body returning handler(value) can infer a common function return type from all selected handlers.", "complete": false, "next_action": "add full function body and Value ABI lowering" }, { "node": "CLASS_DEF", "kind": "stmt", "js_status": "full", "wasm_status": "partial", "js_evidence": "class/extends lower to JS classes", "wasm_evidence": "AST classes lower to generated dict-backed constructor and method functions with inherited method lookup, self-field hints, observed field conflict handling, and class-level plus instance-specific method return hints for string/bool/nil/num/array/dict/function, including constructor-derived function-valued fields that flow through methods and inherited super calls; recursive method return inference is guarded Constructor-observed function-valued fields now retain display/lift hints at the class-field level for later method body lowering. Constructor-observed two-argument function-valued fields now retain enough class-field metadata for method body lowering to dispatch through __sura_call_function_2 across multiple observed constructor targets. Generated class method bodies now have regression evidence for dynamic string-key and numeric-index function-value lookup return inference inside methods, including dict-returning handlers and function-returning handlers. The root source fixture now includes WasmLookupFunctionHolder and root WAT guards proving the normal .sura-to-AST-JSON pipeline emits generated class functions for method-local lookup-selected handlers rather than relying only on the embedded AST smoke fixture.", "complete": false, "next_action": "add inherited class layout, methods, and dynamic dispatch lowering" }, { "node": "NEW_INST", "kind": "stmt", "js_status": "ignored", "wasm_status": "ignored", "js_evidence": "parser no longer emits legacy NewInstStmt; object creation uses NEW_EXPR", "wasm_evidence": "parser no longer emits legacy NewInstStmt; object creation uses NEW_EXPR", "complete": true, "next_action": "none" }, { "node": "RETURN", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "return lowers to JS return", "wasm_evidence": "WASM return statements lower by converting any supported value expression to the target i32/handle representation and emitting return; smoke covers bare returns, numeric returns, direct string/bool/nil/array/dict/function returns, local assignment-derived dynamic values, function-local and if/match-merged new object method-call values, same-type if branch values, same-class if object returns, homogeneous object foreach loop-variable returns, function/method object-param-derived method/field/index string returns, match-arm values, wildcard-covered same-class match object returns, param/self-derived bool logic, and param/self-derived array/dict/function ternary returns for Value truthiness and comparison candidates while mixed branch returns drop hints; array/dict parameter return values are smoke-covered as collection Values at the call site for length(value) and to_bool(value), method return expressions with self-field collection ternaries are stringified branch-wise, inherited super.method array/dict return expressions now feed caller-side full collection to_str(value) plus exact key hint propagation, and function return expressions with argument-resolved collection ternaries now feed caller-side full collection to_str(value) plus exact index/key hint propagation. Mixed Value-returning functions now emit tagged Value return expressions instead of raw numeric lowering, preserving later caller-side Value operations. Direct returns of inline non-capturing function expressions now lower as tagged function Values instead of depending on a preassigned local alias.", "complete": true, "next_action": "none" }, { "node": "BREAK", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "break lowers to JS break", "wasm_evidence": "AST break lowers to the active structured WAT loop break label and is smoke-covered in while, range-for, and repeat loops", "complete": true, "next_action": "none" }, { "node": "CONTINUE", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "continue lowers to JS continue", "wasm_evidence": "AST continue lowers to the active structured WAT loop continue label and is smoke-covered in while, range-for, and repeat loops", "complete": true, "next_action": "none" }, { "node": "THROW", "kind": "stmt", "js_status": "full", "wasm_status": "partial", "js_evidence": "throw lowers to JS throw", "wasm_evidence": "throw expressions are evaluated and dropped before trapping outside main/top-level try; inside AST try/catch they lower to a tagged payload plus global exception side channel. Guards after function, method, and super-method calls propagate throws transitively through supported expression positions before later operands or side effects execute. Catch payloads preserve numeric/string/bool/nil/function values, full array/dict tags, and registered dict-backed instances through a guarded tag-6 object Value; tests/wasm_exception_expression_propagation.sura executes cross-function guards inside nested binary expressions, call arguments, conditions, ternaries, string interpolation, indexes, returns, and array/dict literal construction, with transitive multi-frame propagation and post-throw side effects suppressed; direct new Error-like instances are packed as guarded tag-6 Values before crossing function boundaries Throw payload expressions now apply call side effects before catch/post-try lowering continues, so caught throw payload calls can update later global dict field lowering. Function-valued throw payload analysis now tracks a single promoted/lifted target through direct function and method throw sites for catch-side invocation.", "complete": false, "next_action": "finish fully general object-valued cross-function exception semantics beyond statically discoverable registered classes in WASM" }, { "node": "TRY", "kind": "stmt", "js_status": "full", "wasm_status": "partial", "js_evidence": "try/catch/finally lowers to JS", "wasm_evidence": "AST try/catch/finally lowers structurally with hidden thrown state and tagged payload flow for same-function and transitive cross-function throws. Executable coverage includes binary operands, call arguments, conditions, ternaries, interpolation, indexes, array/dict literals, return expressions, finally blocks, nested rethrows, string/number/heterogeneous-array/dict payload recovery, and registered instance payload recovery with class-union method dispatch. General instance payload semantics beyond statically discoverable registered classes remain partial; tests/wasm_exception_expression_propagation.sura and the full target smoke catch string, number, heterogeneous array, dictionary, and two distinct registered instance payloads after transitive multi-frame propagation, including return and finally paths; a union catch receiver dispatches describe() by the runtime object class id Try/catch flow now preserves global assignment shape hints from throw payload calls, so post-catch statements can lower type(global), global.field, and to_str(global.field) through global dict helpers. Single-target function-valued throw payloads now seed catch-variable display/lift hints, so catch handlers can directly invoke the recovered lifted WASM function. Function-valued throw payloads now seed catch-variable display/lift hints through function parameters observed at throw-call sites, including simple local aliases inside the throwing function. Catch handlers inside child methods can invoke function-valued payloads thrown by super.method(), lowering to the inherited lifted target.", "complete": false, "next_action": "complete fully general instance exception semantics in WASM" }, { "node": "USE", "kind": "stmt", "js_status": "ignored", "wasm_status": "ignored", "js_evidence": "module objects are emitted in JS runtime", "wasm_evidence": "use declarations are compile-time no-ops for numeric WASM", "complete": true, "next_action": "none" }, { "node": "CMD", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "command-style print/assert/type/clock/input/exit/random statements lower through JS source target", "wasm_evidence": "WASM AST command and expression-call print/assert statements lower directly; host-interactive/random builtins are explicitly rejected with diagnostics; AST assert_eq/assert_ne route string/nil/bool Value candidates through tagged equality, assert_type lowers static/hinted runtime type-name checks, and assert_len lowers string/array/dict length checks Command-style print/print_n/print_no_nl now lower through the same dynamic stringification path, including string interpolation and non-numeric values.", "complete": true, "next_action": "none" }, { "node": "EXPR_STMT", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "expression statements lower to JS expressions", "wasm_evidence": "assert/print/call/numeric expression statements and console output API calls lower to side-effect/drop or main-result WAT, with direct function-call exception state bridged into an enclosing AST try block; smoke covers dynamic string, bool, nil, array, dict, function, to_str(array), and to_bool(dict) expression statements lowering through Value helpers and dropping the evaluated result Expression-statement print calls with multiple dynamic values now lower to main-result text through shared Value/string conversion helpers.", "complete": true, "next_action": "none" }, { "node": "TERNARY", "kind": "expr", "js_status": "full", "wasm_status": "full", "js_evidence": "JS ternary expressions are preserved", "wasm_evidence": "numeric ternary lowers to if(result i32), same-type AST string/bool/nil/array/dict ternary expressions feed Value equality, truthiness, function return, collection truthiness, and string concatenation hints, same-branch-visible array/dict literal ternaries stringify through to_str(value), mixed known-type ternary branches lower branch-wise for type(value), length(value), and to_str(value), mixed dynamic ternary expressions wrap each branch in Value form for equality/truthiness, mixed string/nil/bool/num ternary expressions lower branch-wise for string concatenation, and mixed dynamic array/dict/function ternary branches are smoke-covered through Value type(value), length(value), to_bool(value), and to_str(value) helpers Capture analysis now folds ternary expressions whose condition is a proven primitive bool constant before lifting inline function expressions.", "complete": true, "next_action": "none" }, { "node": "FUNC_EXPR", "kind": "expr", "js_status": "full", "wasm_status": "partial", "js_evidence": "JS function expressions lower to closures", "wasm_evidence": "top-level numeric function expressions assigned to a name promote to generated WASM functions; non-capturing function expressions assigned inside functions/blocks are lifted into generated WASM functions and lower as tag-7 function Values for local aliases, type(function), to_bool(function), to_str(function), array/dict storage, and direct local/alias invocation through the lifted function target, including aliases preserved through if/repeat/match control-flow hint merging; promoted top-level function names, aliases, exact array/dict lookups, exact string-key variable dict lookups, and exact numeric-index variable array lookups now lower as tag-7 function Values for type(function), to_bool(function), to_str(function), function Value equality checks, homogeneous array/dict storage, observed function arguments, function-return hints, and direct function-call throw payload catches. Function-value dispatch generates __sura_call_function_N for every arity observed in the module; executable smoke covers runtime-selected targets through twelve arguments. Function-valued exact index lookups used by to_str(function) now still evaluate effectful lookup expressions before lowering to the display string. Non-capturing promoted function expressions now participate in same-arity function-value dispatch through their stable function ids, extending indirect invocation beyond single-target hints. Promoted zero-argument function definitions are now included in function-value dispatch smoke coverage, including zero_a_ast and zero_b_ast targets selected through a runtime handler alias. Promoted two-argument function definitions are now included in function-value dispatch smoke coverage, including add_pair_ast and mul_pair_ast targets selected through a runtime handler alias. Promoted function values selected into local aliases by runtime ternaries are smoke-covered through indirect invocation dispatch, not only type/to_bool/to_str and single-target alias calls. Homogeneous function-valued dict literals are smoke-covered through runtime string-key lookup followed by indirect function invocation. Homogeneous function-valued array literals are smoke-covered through runtime numeric-index lookup followed by indirect two-argument function invocation. Homogeneous function-valued array literals are also smoke-covered through foreach loop-variable invocation, so iteration does not erase callable dispatch metadata. Anonymous non-capturing function expressions nested inside expression trees, including array and dict literals, are now discovered during promotion, emitted as lifted WASM functions, and smoke-covered through type(), to_bool(), and to_str() on exact indexed/field lookups. Direct inline non-capturing function expressions are smoke-covered as first-class function Values for type(func ...), to_bool(func ...), and to_str(func ...), with each anonymous expression promoted to a lifted WASM function while still leaving capturing closures and indirect invocation marked partial. Inline function expressions returned directly from functions are now promoted with a stable return-scoped display/lift name and smoke-covered as callable function Values. Inline function expressions returned by parent methods remain callable after flowing through inherited super.method() calls. Non-capturing function-expression lifting now handles primitive constant captures for number/string/bool/nil locals by substituting proven literal values into the lifted body; smoke covers assigned and returned numeric captures. Primitive constant captures now flow through simple local aliases before inline function-expression lifting, so alias is constant followed by func(...) can still lower to a callable WASM function value. Primitive numeric capture aliases now fold simple arithmetic and comparison expressions before inline function-expression lifting, preserving captures such as adjusted is alias + 3. Primitive string concatenation and boolean comparison captures now fold before inline function-expression lifting, with smoke coverage for captured string and bool-returning zero-arg handlers. Primitive unary not/negation and bool-resolved ternary captures now fold before inline function-expression lifting, so selected primitive branches are preserved in lifted handlers. Primitive null-coalescing and bool and/or captures now fold before inline function-expression lifting, preserving common fallback and guard expressions in lifted handlers. Primitive capture discovery now merges IF branches when both sides prove the same captured primitive value, while dropping branch-divergent captures before lifting inline function expressions. Primitive capture discovery now also merges MATCH arms when all reachable arms prove the same captured primitive value before lifting inline function expressions. Read-only array/dict literal snapshots whose elements are already capturable constants can now feed inline function-expression lifting, with index/dot mutation invalidating the capture root. Inline function-expression lifting now preserves aliases derived from pure calls over captured constant collection snapshots. Lifted inline function expressions now capture direct function aliases and aliases to earlier lifted inline functions used as call targets, so closure bodies such as handler(value) or alias(value) resolve to the captured lifted function target instead of emitting unresolved calls to alias locals. Source smoke now covers an inline wrapper around a ternary-selected function value, proving the wrapper call is lowered in the enclosing function context and preserves dynamic dispatch for runtime-selected handlers. Runtime-parameter-capturing inline function expressions now separate non-escaping inline lowering from independent lifted-function promotion, so direct local closure calls can use enclosing parameters without emitting invalid lifted WAT bodies with unbound locals. Function expressions returned directly from a function and capturing that function\u0027s call arguments now specialize at the call site into a dispatchable lifted WASM function value instead of returning an unusable generic closure id. Returned closure specialization now treats a call target name inside handler(value) as a free capture, so generic lifting is skipped until a call-site argument such as block_double_ast or bump_param can be substituted into the returned function body. Direct return-factory specialization now also folds pure local aliases derived from factory call arguments before lifting the returned function expression, covering adjusted = bonus + 1 followed by a returned closure over adjusted. Direct return-factory specialization now merges pure if-branch capture maps when both branches prove the same captured primitive value, allowing returned closures over branch-assigned locals to specialize safely. Direct return-factory specialization now preserves pre-if captures when a captured false condition has no else branch before returning a closure. Direct return-factory specialization now treats an unknown pure if without an else branch as a merge between the then captures and an empty else path, so unrelated pre-if captures remain available to returned closures. Direct return-factory specialization now resolves literal/wildcard match arms and merges pure match-arm capture maps when all reachable arms prove the same primitive value, allowing returned closures over match-assigned locals to specialize safely. Direct return-factory specialization now preserves pre-match captures when a literal match subject is proven to execute no arm before returning a closure. Direct return-factory specialization and nested function-expression promotion now apply bounded exact repeat capture updates before lifting returned closures, including cumulative repeat-body assignments that depend on the previous captured value. Direct return-factory specialization now also applies bounded static range-for capture updates before lifting returned closures, including loop-variable-dependent cumulative assignments. Static range-for analysis now preserves zero-iteration loops as an empty proven iteration set, so returned closures can skip unreachable loop bodies before lifting. Direct return-factory specialization now applies static foreach capture updates over capturable array and dict literal snapshots before lifting returned closures, including key/value loop variables. Static foreach analysis now preserves empty array/dict snapshots as an empty proven iteration set, so returned closures can skip unreachable foreach bodies before lifting, including dict key/value loop variables. Direct return-factory specialization now resolves captured false while conditions and skips unreachable loop bodies before lifting returned closures, preserving pre-loop captures. Direct return-factory specialization now also resolves literal false while conditions and skips unreachable loop bodies before lifting returned closures.", "complete": false, "next_action": "add capturing closures and fully indirect function-value invocation beyond lifted non-capturing function values" }, { "node": "STR_INTERP", "kind": "expr", "js_status": "full", "wasm_status": "partial", "js_evidence": "JS template strings lower interpolations", "wasm_evidence": "AST numeric string interpolation plus JSON escaped string literal code points, hinted dict/array/class-field/class-method string/bool/nil interpolation, homogeneous array dynamic-index interpolation, exact numeric-index variable mixed primitive array type/length/to_bool/to_str interpolation, direct function-call-returned exact numeric-index mixed primitive array type/to_bool/to_str interpolation, method-call-derived exact numeric-index mixed primitive array type/length/to_bool/to_str interpolation, exact string-key variable mixed primitive dict type/length/to_bool/to_str interpolation, direct function-call-returned exact string-key/field mixed primitive dict type/to_bool/to_str interpolation, dynamic string-key dict interpolation including function-valued collection lookups through type(function)/to_bool(function), static/hinted and branch-sensitive mixed ternary type(value), branch-sensitive mixed ternary length(value), branch-sensitive mixed ternary to_str(value), primitive to_str(value), exact numeric-index variable mixed primitive array element to_str(value), direct/alias/exact lookup, exact string-key variable lookup, and exact numeric-index variable lookup promoted function to_str(function), visible array/dict literal, nested collection variables inside literal to_str interpolation, homogeneous array variable, fixed-index mixed primitive array variable, direct function-call-returned fixed-index mixed primitive array bare and to_str interpolation, fixed-key mixed primitive dict variable, direct function-call-returned fixed-key mixed primitive dict bare and to_str interpolation, and ternary literal to_str interpolation, value-aware to_bool(value), and promoted function type/truthiness interpolation, expression-valued bool comparison interpolation, and raw STR_LIT interpolation expressions with direct object-returning call/new/ternary receivers for dot, method, and string-key index access lower through __sura_i32_to_string and __sura_string_concat into the array-like string representation String interpolation now smoke-covers string-returning function-value dispatch results, preserving the user call through the WASM function-value dispatcher instead of falling back to unreachable or numeric stringification. String interpolation now also covers bool, array, nil, dict, and function-returning function-value dispatch results through direct bool/nil formatting, collection to_str(value), field reads, and returned function calls. String interpolation now smoke-covers values returned from lifted inline functions that captured folded string and bool primitive constants. String interpolation smoke now covers strings captured from to_str(array/dict snapshot) aliases inside lifted inline functions. Captured string interpolation aliases now fold primitive and constant collection placeholders before inline function-expression lifting. Optional access combined with null coalescing can now feed the WASM string path without falling back to unsupported binary operators. Raw string interpolation parsing now recognizes ?? as an AST BIN_OP, so numeric coalescing over mixed runtime index/dot accesses avoids the legacy expression fallback. String conversion for null coalescing now routes through the tagged Value stringifier instead of raw i32 truthiness, preserving mixed-type coalescing results in interpolation. String interpolation smoke now covers optional-access null coalescing expressions and collection fallbacks routed through to_str(value). Mixed ternary collection index and dot expressions inside bare interpolation now stringify through __sura_value_index/__sura_value_field plus __sura_value_to_string, preserving string and nil results without raw i32 conversion. Direct function-call-returned collection length/truthiness interpolation is covered without falling back to nil. Method-returned constructor-field arrays/dicts now stringify inside interpolation without falling back to unsupported collection errors, including full-or-empty self-field ternaries, local aliases, inherited super.method collection returns, and exact index/key reads. Conditional function-returned arrays/dicts now stringify full-or-empty branches and aliases inside interpolation, exact index/key reads now stringify without falling back to unsupported dynamic values, and raw STR_LIT interpolation prepass parses calls so AST JSON string literals can still provide function-parameter collection-shape hints. Runtime-selected tagged Values now stringify registered objects as \u003cInstance ClassName\u003e, known function ids as \u003cFunc displayName\u003e, and non-empty typed raw arrays with metadata tags 0 through 7 through recursive dynamic-array conversion. Empty raw arrays stringify as []. Metadata-less non-empty raw arrays and raw tag-5 dictionaries without ordered entry metadata still use their type-name fallback, so STR_INTERP remains partial. tests/wasm_dynamic_interpolation_value.sura executes matching native VM, JIT-entry, and emitted WebAssembly output for runtime-selected number, string, bool, nil, typed array, mixed dynamic array, object/function array, ordered dictionary, function, and caught object values.", "complete": false, "next_action": "extend string interpolation over the full dynamic Value/string runtime" }, { "node": "MATCH", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "match/when lower to JS matched-arm blocks", "wasm_evidence": "numeric match/when, block-style arms, wildcard arms in first/middle/final positions, range arms, tilde ranges, exact string/bool/nil/value-candidate arms, dynamic dict/index subject values, and dynamic nil subject values lower to WAT matched-arm blocks with tagged Value equality where needed; match arms cover dynamic Value operations for array type/length, dict truthiness, function type/truthiness/stringification, inline branch-local declarations, and string concatenation; same-type match-arm returns feed function call Value hints, wildcard-covered same-class object returns feed object-returning call hints, same-type arm value/object assignment hints merge after match, and conflicting arm assignment hints are dropped Match subject expressions now apply call side effects before arm hint snapshots, so subject calls can update later global dict field lowering. MATCH arm capture maps now merge shared equal primitive constants, including wildcard-covered arms, and include the no-match path when no wildcard arm exists.", "complete": true, "next_action": "none" }, { "node": "ENUM_DEF", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "enums lower to JS objects", "wasm_evidence": "numeric enum members lower to i32 constants, while string and bare enum members lower to length-prefixed string constants; bare members default to their name", "complete": true, "next_action": "none" }, { "node": "IMPORT", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "JS target recursively expands source imports and AST JSON imports before lowering", "wasm_evidence": "WASM target recursively expands source imports and AST JSON imports before numeric lowering", "complete": true, "next_action": "none" }, { "node": "GLOBAL_DECL", "kind": "stmt", "js_status": "full", "wasm_status": "full", "js_evidence": "global declarations lower to JS scope comments while top-level vars remain shared through generated JS function closures", "wasm_evidence": "WASM AST lowers global declarations to mutable i32-backed module globals in the portable subset, covering numeric values plus string/array/dict runtime handles and bool/nil/function tagged Value flows through global.get/global.set, including Value type(value), length(value), to_bool(value), to_str(value), field/index reads and writes, class constructor/method side effects, branch/loop/match/try/call side-effect propagation, and function-valued global stringification hints; function-returned global string/array/dict handles are smoke-covered when reused by the caller through string concat, array indexing, and dict dot access. Function-body pre-scan applies global declarations across the whole function before statement lowering, so use-before-declaration sites lower to module globals rather than locals. Global string/array/dict handles are smoke-covered through dynamic type(), length(), and to_bool() lowering with Value wrappers. Function-call global assignment effects are smoke-covered: a function that writes a dict to a declared global updates caller-side type and field hints so later type(global), global.field, and to_str(global.field) lower through global.get plus Value/dict helpers. IF condition call side effects are smoke-covered: a condition function that writes a dict to a declared global updates caller-side type and field hints before later statements lower type(global), global.field, and to_str(global.field). Loop pre-evaluation call side effects are smoke-covered for while conditions, repeat counts, for bounds, and foreach collections, including zero-iteration loops whose setup expressions still update global dict shape hints. Match subject call side effects are smoke-covered: a subject function that writes a dict to a declared global updates caller-side type and field hints before later statements lower global field reads. Throw payload call side effects are smoke-covered: a payload function that writes a dict to a declared global updates caller-side type and field hints before catch/post-try statements lower global field reads.", "complete": true, "next_action": "none" } ], "next_actions": [ "Finish upgrading partial WASM AST nodes from numeric/hinted lowering to full dynamic Value semantics.", "Wire the tagged dynamic Value ABI fully into WASM AST lowering for strings, nil, dicts, objects, function values, classes, and exceptions.", "Keep this audit in CI/release evidence so target parity gaps cannot be hidden by passing subset smoke tests." ] }