Conformance

This page maps each part of the specification to the tests that cover it. It also defines what a conforming program and a conforming implementation must do.

Conforming Programs And Implementations

A conforming Aura program uses only syntax and APIs defined by this Manual and satisfies all static rules.

A conforming Aura implementation:

• accepts every conforming program within documented implementation limits
• rejects programs that violate a MUST-level lexical, grammatical, name, type, ownership, or entrypoint rule
• preserves the observable evaluation and cleanup behavior defined by the Manual
• produces the specified typed outcomes or runtime failures
• provides the maintained public API surface
• does not expose proposal-only constructs as accepted 0.6 language features

Exact diagnostic prose is normative only where a fixture or this Manual explicitly requires it. Otherwise, a conforming implementation needs a clear diagnostic with an accurate source location and the same stable AU#### code. The message wording may differ, as long as the code keeps its documented meaning.

Executable Reference Map

Each row names a reference area and the tests, fixtures, and maintained examples that serve as its evidence. "MIR" is Aura's mid-level intermediate representation, which aura run executes. "The parity matrix" is the backend-equivalence test described under Backend Equivalence.

Reference area	Primary executable evidence
UTF-8, indentation, tokens, literals, escapes	crates/aura-compiler/src/lexer_tests.rs
Delimiter continuation, ignored continuation indentation, expression-match layout islands, trailing-comma/backslash/single-line-string boundaries, and pairing diagnostics	focused lexer/parser tests; newline_continuation* and delimiter parse/run fixtures; examples/basics/multiline_expressions.au; compiler-bridge and extension indentation tests; and the MIR/direct parity matrix
Parenthesized tuple values/types, recursive assignment/loop targets and patterns, function returns, left-to-right capture, recursive Copy, whole-source non-Copy moves, shared leaf provenance, copy-only constant indexing, canonical rendering, same-type recursive structural ==/!= with non-consuming reads, retained ordering rejection, and mutable-writeback rejections	focused lexer/parser/sema/MIR/native/runtime tests; the tuple_structural_equality, tuple_equality_contextual_literals, and retained tuple_ordering_rejected fixtures; other tuple_* parse/check/run fixtures; examples/basics/tuples.au; the compiler-bridge tuple equality/ordering regression; and the MIR/direct parity matrix
grammar and parser limits	crates/aura-compiler/src/parser_tests.rs, tests/fixtures/parse-pass, tests/fixtures/parse-fail
FFI v0 package authorization and root dependency reports; bodyless extern/opaque grammar; fixed-width scalar, null-empty and pointer-length view ABI; same-length mutable copy-in/out and post-call writeback; opaque ownership and non-Transfer rules; direct-call-only process-global lookup; Unix MIR/direct parity; LSP/editor support; and reserved callbacks/raw pointers/variadics	focused lexer/parser/package/sema/analysis/MIR/native/runtime tests; crates/aura-compiler/tests/ffi_frontend.rs; crates/aura/tests/ffi_acceptance.rs; examples/packages/ffi_getpid; language-server recovery/compiler-bridge tests; extension grammar/snippet tests; and the forced backend parity matrix
Conditional-expression precedence, exact-bool conditions, arm unification/context, lazy condition-first selection, conservative branch moves, analysis, and backend parity	focused conditional parser/sema/MIR/analysis tests; conditional_expression_* check/parse fixtures; conditional_expressions run fixture and example; compiler-bridge coverage; and the MIR/direct parity matrix
Membership containers and delegation, chained-comparison precedence, at-most-once operand evaluation, short-circuiting, conservative chain checking, and backend parity	comparison_chains_keep_every_operator_at_one_precedence_level, membership_tests_read_supported_containers_and_reject_the_rest, and comparison_chains_evaluate_each_operand_once_and_short_circuit; membership_* check-fail and membership_and_comparison_chains check-pass fixtures; the membership_and_comparison_chains run fixture and example; five Python-shaped acceptance fixtures; and the MIR/direct parity matrix
enumerate/zip loop-form recognition, operand domain, bare shared default, int64 positions, shortest-operand zip termination, shadowing, function-wide per-loop binding-slot isolation under heterogeneous binding-name reuse, and backend parity	enumerate_and_zip_iterate_in_lockstep_over_the_bare_loop_default, heterogeneous_ordinary_for_bindings_use_distinct_scoped_typed_slots, every_ordinary_for_form_uses_a_fresh_scoped_target_slot, and ordinary_for_target_scope_starts_after_iterable_evaluation; enumerate_requires_indexable_iterable and zip_rejects_ownership_modifiers check-fail fixtures; the reversed heterogeneous enumerate_and_zip fixture; tuple_for_pattern_queue for recursive target reuse; list_mut_iteration and iteration_element_loan_write_through for write-through on fallthrough, continue, break, and explicit return; the maintained example; and the MIR/direct parity matrix
len delegation domain; shared int64 type and value across len(x) and x.len() for str, list, dict, and set; str.byte_len() as an int64 UTF-8-byte count; str rendering equality with print and f-strings; and the reservation of both names	focused semantic, call-surface, MIR, native-codegen, runtime, analysis, and language-server tests; the len_requires_a_len_member check-fail fixture; the len_and_str run fixture and example; two Python-shaped acceptance fixtures; and the MIR/direct parity matrix
Unified int64 index domain: direct indices, slices, range bounds and yields, enumerate positions, Array coordinates, selection indices, collection lengths/search positions/capacity arguments, scoped lossless widening of fixed-width integer position values, exact list[int64] coordinate containers, and target-stable rejection outside that scope	index_domain_positions_contextually_type_literals_as_int64, index_domain_accepts_default_int64_variables, and focused semantic/MIR/native/runtime/analysis tests; index_domain_int64_contract, index_domain_lossless_widening, index_domain_rejects_uint64, and boundary fixtures; index_domain_zero_cast_idioms, which pins values[values.len() - 1], range(values.len()), and enumerate-index-back-into-list without casts; examples/collections/list_polish.au; and the forced MIR/direct parity matrix
Canonical list/dict/set/str surface: homogeneous literals, exact constructors and method signatures, first-match list search, stable natural/key sorting, typed dictionary absence and eager snapshots, loud/silent set removal, capacity control, exact ownership and evaluation order, AU4008/AU4003/AU4005 failures, analysis/editor exposure, and backend parity	focused parser, call-surface, semantic, MIR, native, runtime-value, analysis, language-server, and extension tests; canonical_collection_surface, collection capacity, obligation, missing-value, and ownership fixture families; examples/collections/list_basics.au, list_polish.au, dict_basics.au, and set_basics.au; the clean-surface identity gate; and the forced MIR/direct parity matrix
names, types, calls, traits, patterns, moves, and borrows	crates/aura-compiler/src/sema_tests.rs, tests/fixtures/check-pass, tests/fixtures/check-fail
Prelude Display implementation rules, dispatch through print, str, f-strings, and nested rendering, the custom-Display format subset, trap-before-write print, and read-only @property declaration, read, and use rules	the display_* and property_* parse-fail, check-fail, check-path-fail, run-pass, and run-fail fixtures; properties_hover_complete_and_navigate_as_properties and property_hover_and_completion_show_the_getter_docstring; examples/traits/display.au and examples/classes/properties.au with their CLI run and direct-build tests; and the MIR/direct parity matrix
Module-level function decorators: parsing and grouping, top-to-bottom evaluation and bottom-to-top application, recursion through the decorated binding, initialization traps, AU2047 rejections, cross-module calls, hover, aura doc, and formatting	the decorator_* parse-fail, check-fail, run-pass, and run-fail fixtures; decorated_functions_work_across_modules_on_both_backends; decorated_functions_hover_with_their_decorators_and_hide_generated_names; api_docs_list_a_decorated_function_with_its_decorators_and_docstring; decorators_attach_to_their_definition; and examples/basics/decorators.au
Generic decorators and generic decorator factories inferred per use, generic callable alias packing, renamed-parameter and own-parameter decorator diagnostics	the decorators_generic and callable_alias_generic_pack run-pass fixtures; the decorator_generic_*, decorator_retry_own_parameter, and callable_alias_generic_* check-fail fixtures; generic_decorators_infer_each_use_across_modules_on_both_backends; and examples/basics/retry_decorator.au
integer / rejection, floor division/remainder, exact float-context integer literals, .to_float(), and shortest-roundtrip float printing	lexer/parser/integer/runtime-value unit tests plus integer_true_division_*, floor_division_and_modulo, float_context_integer_literals, integer_to_float_rounding, and float_shortest_roundtrip_printing fixtures
Decimal separators and hexadecimal/binary/octal integer literals; exact-width bitwise operators; checked, wrapping, and saturating shifts; exact count typing/ranges; compound-store ordering; and MIR/direct parity	focused lexer/parser/sema/integer/MIR/native/runtime tests; literal and shift failure fixtures; the bitwise_power runtime fixture; examples/numbers/bit_packing.au; language-server and extension coverage; and the forced MIR/direct parity matrix
Math Module scalar constants and functions: exact immutable float64 constant bits, generic once-initialized module storage, exact function signatures, checked int64 rounding conversions, IEEE-754 identity and exceptional-value classification, finite overflow and domain diagnostics, left-to-right once-only evaluation, and MIR/direct parity	math_namespace_exposes_exact_generic_float64_constants, math_namespace_exposes_the_exact_float64_function_contract, math_host_builtins_follow_the_ratified_finite_contract, math_host_builtins_classify_every_exception_family, math_analysis_exposes_qualified_and_aliased_constant_details, math_analysis_completes_and_hovers_the_exact_public_surface, and focused semantic tests; the math_module_constants, math_module_functions, and math_log_domain fixtures; examples/numbers/scalar_math.au; compiler-bridge coverage; and the forced MIR/direct parity matrix
Power, round, and divmod: right-associative precedence, exact numeric types, checked integer results, ties-to-even conversion, paired floor quotient/remainder, runtime classification, one-time evaluation, and MIR/direct parity	focused parser/sema/integer/runtime-value/MIR/native tests; numeric_round_divmod, bitwise_power, and numeric failure fixtures; examples/numbers/bit_packing.au; language-server and extension coverage; and the forced MIR/direct parity matrix
Exact triple-quoted and raw string forms plus static f-string format specifications: delimiter and escape rules, no whitespace normalization, Unicode-scalar width and string precision, sign-aware numeric zero padding, type-directed numeric codes, binary32 identity, left-to-right evaluation, focused raw/triple-f diagnostics, formatter preservation, and MIR/direct parity	focused lexer/parser/sema/runtime-value/MIR/native tests; string_literal_forms_and_format_specs, fstring_zero_padding, and fstring_* rejection fixtures; examples/strings/literal_forms_and_formatting.au; compiler-bridge and extension grammar/snippet tests; and the forced MIR/direct parity matrix
Match guards, or-patterns, and top-level catch-all bindings: exact-bool guards, left-to-right alternatives, identical alternative bindings, guarded-arm reachability and exhaustiveness, delayed match own extraction, mutable candidate writeback before false continuation/failure/trap and every selected-arm exit, complete-scrutinee binding capabilities, and MIR/direct parity	focused parser/sema/MIR/analysis tests; the match_guard*, match_own*, match_mut_guard*, match_root_binding_patterns, or_pattern*, guarded-exhaustiveness, and match_expression_class_variant_pattern fixtures; examples/enums/match_guards_and_or_patterns.au; compiler-bridge tests; and the forced MIR/direct parity matrix
Tuple rest elements in targets and patterns, list sequence patterns in bare match, and keyword class patterns: rest ranges, AU2041 placement and arity rejections, length tests, owned rest slices, class and union-member selection, matching every generic specialization in a union, field visibility, match own field moves, AU2040 rejections, structural exhaustiveness, analysis hover and definition, and MIR/direct parity	focused parser and analysis tests; the tuple_rest_unpacking, list_sequence_patterns, class_patterns, class_and_sequence_patterns_nested, class_pattern_imported, class_pattern_generic_union, and sequence_rest_beside_type_pattern run fixtures; the pattern_* parse-fail and check-fail fixtures; class_pattern_private_field and class_pattern_generic_union_field_types; examples/enums/structural_patterns.au; and the forced MIR/direct parity matrix
Module constants: inferred/annotated/public declarations, declaration-order scope, dependency-first and source-ordered eager once-only initialization, one defining storage identity, Copy versus shared non-Copy reads, move/mutation rejection, guarded re-entry, package visibility, analysis/editor exposure, cleanup, and MIR/direct parity	focused parser/sema/MIR/native/runtime/analysis tests; module_constant* check/run fixtures; multi-module and package dependency tests; examples/modules/constants.au; language-server compiler-bridge tests; and the forced MIR/direct parity matrix
signed-i128-nanosecond Duration literals, exact two-limb direct ABI, constructors, checked arithmetic, FloorDiv, comparison, conversion, rendering, and invalid host timers	duration_literals_scale_to_nonnegative_i128_nanoseconds_at_each_unit_boundary, parser/MIR/native-codegen/runtime unit tests, Duration run/failure fixtures, native-runtime FFI tests, and the MIR/direct parity matrix
persistent descriptor registrations, heap-ordered deadlines, direct Queue/task-completion/blocking-pool wakeups, wait-epoch race containment, one-winner cleanup, and event-or-deadline idle blocking without a periodic tick	runtime_reactor unit tests including timers_fire_at_the_earliest_deadline_and_preserve_equal_deadline_order, one_persistent_fd_registration_aggregates_waiters_and_narrows_interest, and waker_coalescing_does_not_lose_inbox_entries_and_ready_is_deduplicated; runtime-value direct-wakeup and cleanup tests; scheduler_model lost-wake/stale-epoch/one-winner state-space tests; scheduler_mixed_wakeups_complete_in_mir_and_direct_backends; scripts/stress-scheduler.sh; the contractual scripts/bench-scalable-runtime.py after-reactor run; and the MIR/direct parity matrix
yield_now cooperative scheduling, zero-argument typing, explicit ready-set requeue, unit result, and backend parity	focused call-surface, semantic, MIR-runtime, native-codegen, analysis, language-server, and extension tests; the yield_now check/run fixtures; examples/concurrency/yield_now.au; and the forced MIR/direct parity matrix
compiler-inserted scheduling checks on every ordinary and continue loop backedge; exit-path bypass; no implicit cancellation check; amortized function-local MIR/native fuel; sequential-program elision; and timer/Queue/socket progress on both backends	focused MIR lowering, MIR-runtime, native-codegen, and validation tests; loop_backedge_safepoints_prevent_timer_and_queue_starvation; the loopback-socket safepoint regression; the sleeper_vs_hot_loop.au scalable-runtime workload; the contractual starvation benchmark; and the forced MIR/direct parity matrix
Guarded 768 KiB default task stacks, exact int64 256 KiB..64 MiB collision-free overrides with 256 KiB reserved for measured shallow tasks, page rounding without clamping, and off-coroutine HTTP/TLS/WebSocket protocol steps	focused call-surface, semantic, MIR, native-codegen, scheduler-allocation, protocol-service, recursion, language-server, and both-backend CLI tests; maintained loopback HTTP, TLS, and WebSocket round trips; the scalable-runtime same-process baseline/parked-task measurements; and the MIR/direct parity matrix
unique mutable scheduler ownership; owned nested-start admission with synchronous preparation failure and safe immediate waits; internal FIFO admission without a public scheduling-order promise; teardown cancellation and observer wakeup; MIR/Rust unwind; and exact-once direct child/root stack-reset containment	nested_spawns_are_fifo_and_an_immediate_child_wait_is_safe, nested_stack_allocation_failure_is_synchronous_and_does_not_enqueue_a_task, lightweight_scheduler_teardown_cancels_abandoned_tasks_and_runs_cleanup_once, pure_rust_abandoned_task_unwinds_owned_values_once_at_teardown, direct_cleanup_can_spawn_a_child_before_the_parent_is_retired, and generated_root_cleanup_runs_once_on_forced_exit_and_not_on_normal_return in runtime_value_tests; the direct-root, unstarted-task, started-task, and normal-completion ownership tests in native_runtime_tests; the event-multiset oracle in scheduler_nested_spawns.au; nested_scheduler_spawns_preserve_outcomes_cleanup_and_backend_parity; and the raw-scheduler-alias rejection in scripts/check-hygiene.sh
Structural Transfer, owned Copy snapshots, explicit/concrete generic task targets, Queue constructor/send payload enforcement, conditional Task Copy, static single-consumer observation, AU3008 boundary diagnostics, AU3009 duplication diagnostics, and atomic one-winner runtime defense	task_boundaries_accept_structurally_transferable_values_and_results, task_boundary_diagnostics_explain_the_exact_nested_non_transfer_reason, task_transfer_checks_use_the_concrete_generic_specialization, queue_transport_requires_transfer_payloads_but_handle_only_methods_do_not, owned_builtin_snapshots_are_transfer_but_live_authority_is_not, task_target_explicit_specialization_and_contextual_defaults_are_concrete, task_capture_materializes_copy_snapshots_but_not_noncopy_shared_views, task_result_observation_rights_follow_repeatability, and clone_producing_operations_cannot_duplicate_task_observation_rights; runtime-value, MIR-runtime, and native-runtime claim tests; the task_transfer_*, queue_transfer_*, and task_result_* check fixtures; task_transfer_runtime_matrix.au; its MIR/direct CLI parity test; compiler-service/LSP evidence; and the forced backend parity matrix
Pinned-worker multicore task execution, available-core default, provisional positive AURA_WORKERS override and exact AU4006 rejection, stable spawn-time affinity across yield/timer/Queue waits, no migration or work stealing, cross-worker Queue/Task wakeups, per-task cancellation/diagnostic isolation, and MIR/direct parity with unspecified scheduling/output order	lightweight_worker_count_defaults_and_rejects_invalid_overrides, lightweight_tasks_are_pinned_across_yield_timer_and_queue_waits, lightweight_workers_make_cpu_progress_concurrently, task-context isolation tests, the multicore_queue_task_matrix run fixture, its MIR/direct CLI parity test, and the forced backend parity matrix
Blocking-I/O worker configuration, optional pending-only queue capacity, exact explicit counts, compatible unbounded default, FIFO scheduler-aware admission, pre-acceptance timeout/cancellation, accepted-job abandonment, lazy all-or-nothing startup, fatal pre-user-code AU4006 validation, resolver-saturation recovery, default-parallel watchdog stability, and MIR/direct/standalone parity	runtime_config decoding tests; focused BlockingIoPool lifecycle, capacity, FIFO, race, abandonment, and injected-resolver tests in runtime_value_tests; forced-backend and standalone configuration/admission tests in crates/aura/tests/cli.rs; and the MIR/direct parity matrix
Typed runtime call frames and task ancestry, once-only pre-cleanup capture, per-frame source paths, human-note synthesis, additive diagnostic-schema-v1/LSP propagation, native private trap transport, normal-status distinction, and exact MIR/direct parity without frame masking	diagnostic, MIR-runtime, native-runtime, native-codegen, CLI cold/warm/concurrent-cache, LSP bridge, run-fail fixture, and complete forced-backend parity tests
deterministic xoshiro256** seeding/output, unbiased half-open integers, 53-bit floats, Fisher-Yates writeback, rendering, unavailable equality, direct and transitive no-clone ownership, inferred generic and trait clone-safety contracts, and OS-secure integer/byte boundaries	src/randomness.rs; random_rng_clone_safety_defers_generic_obligations_to_use_sites, imported_rng_clone_obligations_and_qualified_wrapper_identity_survive_namespaces, and focused trait/operator/From semantic tests; random_deterministic_sequences, random_projected_shuffle, random_render, equality_rng_direct, random_transitive_clone_rejected, random_secure_smoke, random_invalid_*, random_secure_bytes_request_ceiling, and random_secure_bytes_request_ceiling_i64_max fixtures; native-runtime FFI and language-server tests; and the MIR/direct parity matrix
list[uint8] bytes, strict UTF-8 conversion, lowercase/mixed-case hex, canonical padded base64, typed malformed-input offsets, raw SHA-256, shared inputs, and output-size preflights	src/bytes_codec.rs unit tests; bytes_codecs_and_hashing, bytes_typed_errors, and reserved-encoding fixtures; examples/bytes/codecs_and_hashing.au; language-server tests; allocation-boundary tests; and the MIR/direct parity matrix
Assertion introspection: exact operand types, once-only left-to-right comparison and membership evaluation, shared-dispatch eligibility, bounded typed operand captures, lazy once-only messages, exact default/custom/empty/whitespace text, AU4001 keyword span, operand and cleanup precedence, schema-1 structured fields, top-level scripts, and no stripping	assert_* parse/check/run fixtures and compiler unit tests; assertion CLI tests for forced MIR/direct execution and function-level aura test; examples/basics/assertions.au; language-server and extension packaging tests; and the MIR/direct parity matrix
Test runner: source-order function and file-level discovery, canonical names, literal case-sensitive -k after expansion, zero-match success, per-case isolated setup/case/teardown ordering, teardown-after-trap and structured secondary failure, one-time ordered parameter registration with capture-free functions, output capture, timeouts, normalized paths, and schema-versioned ordered JSON records	the aura_test_* CLI family covering discovery, filters, JSON, hooks, checked-module reuse, FFI, parameter registration, capture rejection, labels, and timeouts; aura_test_maintained_assertions_example_pins_the_runner_contract; examples/basics/assertions.au; the normative CLI and Tooling testing contract; and the completion matrix in the testing design record
Application-level HTTP retry composition: retry only 503, deterministic seed-42 jitter, exponential Duration backoff, final-attempt no-RNG/no-sleep behavior, explicit deadlines, and scoped resource cleanup	examples/agents/retrying_network_worker.au and retrying_network_worker_runs_with_computed_backoff_on_both_backends in crates/aura/tests/cli.rs, which pin the exact seven-request loopback trace on the MIR and forced-direct backends
Callable-powered list algorithms: stable mutable natural/key sorting, once-only left-to-right key evaluation before mutation, trap-before-mutation, eager shared map/filter traversal, owned results, source retention, exact shared callback capabilities, and filter clone safety	list_algorithm_callbacks, list_sort_requires_mut_receiver, list_sort_rejects_non_orderable, list_map_callback_requires_shared, list_filter_rng_clone_safety, and builtin-collision fixtures; focused semantic, MIR, runtime, native, analysis, and LSP tests; examples/collections/list_algorithms.au; and the MIR/direct parity matrix
control.retry: immediate first attempt, every-Err retry policy, exact attempt budget, doubling Duration backoff, zero-delay sleep elision, no post-final sleep/multiply, exact last-error return, worker-trap/overflow/cancellation propagation, and both-backend behavior	control_retry_surface parse/check fixtures; control_retry_basics run fixture; focused compiler/runtime tests; crates/aura/tests/control_retry.rs; examples/agents/retry_with_backoff.au; and the MIR/direct parity matrix
Expression closures: contextual bare/mut/own parameters, expression-only bodies, implicit Copy snapshots, non-Copy move-at-creation, repeatable reads, consuming single-use calls, structural Transfer, cleanup, and MIR/direct parity	lambda parser/check/run/failure fixture families; focused semantic, MIR, runtime, native-codegen, analysis, completion, language-server, and extension tests; examples/basics/closures.au; and the forced MIR/direct parity matrix
Place-based loans and views: root/field/fixed-tuple identity, shared/mutable local views, inferred final-use regions, returned receiver/parameter views, reborrowing, exhaustive loan capture lists, mutable-repeatable closures, non-Transfer escape rejection, exit cleanup, AU3010, analysis/editor exposure, and MIR/direct write-through parity	focused view parser, semantic, analysis, MIR, MIR-runtime, native-codegen, and native-runtime tests; place_views.au; examples/basics/views.au; language-server/compiler-bridge and extension protocol tests; and the forced MIR/direct parity matrix
Eager owned comprehensions: list/set/dictionary forms, exact-Boolean filters, progressive non-leaking target scope, nested outer-major order, left-to-right filters, dictionary key-before-value replacement, every bare iterable including Queue receive ownership, explicit clone/move behavior, closure capture interaction, generator/modifier teaching diagnostics, cleanup, and MIR/direct parity	comprehension parser/check/run/failure fixture families; focused semantic, MIR, runtime, analysis, completion, language-server, and extension tests; examples/collections/comprehensions.au; and the forced MIR/direct parity matrix
Owned list/str slices under the unified int64 index domain: all omitted endpoint forms, int64 endpoints with scoped lossless widening, once-only negative normalization, no clamping, invalid/reversed AU4003, Unicode-scalar str O(n) behavior, list clone-safety and task-repeatability, retained evaluate-once order, source/result independence, reserved step/assignment AU2005, str integer-index rejection, and MIR/direct parity	slice parser/check/run/failure fixture families; focused semantic, MIR, runtime, analysis, completion, language-server, and extension tests; examples/collections/slices.au; and the forced MIR/direct parity matrix
Contiguous numeric Arrays and explicit integer modes: four exact dtypes, rank-at-least-one row-major owned storage, zero dimensions, constructor/count checks, multidimensional indexing, first-axis copy slices, exact-shape/scalar kernels, float-only division, deterministic row-major map/reductions, float64 mean, checked/wrapping/saturating integer behavior, AU4002 checked Array overflow and AU4004 floating Array zero-divisor failures, AU4003 coordinate/slice bounds, AU4005 allocation/element-count failures, AU4007 shape/rank/count/empty-reduction failures, and no array-shape broadcasting/views/promotion/accelerator	numeric-array semantic/MIR/runtime/native/parity fixture families, including synchronized checked-overflow and floating-zero-divisor diagnostics; compiler analysis, language-server, and extension protocol tests; examples/numbers/numeric_arrays.au; the tested bench-numeric-arrays.py raw/summary evidence protocol; and the forced MIR/direct parity matrix
recursive JSON parse/dump semantics, exact numeric classification, typed parse errors, deterministic formatting, accessors, ownership, and resource limits	JSON codec/runtime-value unit tests, including exact materialized-node boundaries and deterministic allocation-failure injection; json_dynamic_values, JSON ownership and run-fail fixtures; examples/json/dynamic_values.au; language-server tests; and the MIR/direct parity matrix
dict duplicate-key replacement, key-before-value effects, indexed-read/simple-write ownership, and missing-key traps	dict_literal_duplicate_keys, dict_index_non_copy_requires_explicit_clone, dict_index_assignment_consumes_noncopy_key, and dict_index_missing_key fixtures plus the MIR/native parity matrix
Supplied/default order and named enum-argument source order with declaration-slot binding	explicit_and_default_argument_order plus the MIR/native parity matrix
Copy-value capture, immediate f-string rendering, and receiver-before-argument effects	left_to_right_value_snapshotting plus the MIR/native parity matrix
Compound binary dispatch for root/projected targets, copy-target capture, retained non-copy AU3002, and copy-only list/dict indexed targets	operator_traits, left_to_right_value_snapshotting, compound_noncopy_target_rejects_rhs_mutation, list_compound_assignment_noncopy_element_rejected, and dict_compound_assignment_noncopy_value_rejected fixtures plus the MIR/native parity matrix
Dedicated AU3005/AU3006 indexed ownership codes, AU3003 mutable-receiver classification, and AU2005 str-constructor guidance	list_index_non_copy_requires_explicit_clone, dict_index_non_copy_requires_explicit_clone, list_compound_assignment_noncopy_element_rejected, dict_compound_assignment_noncopy_value_rejected, immutable_mutating_method, and string_constructor_not_supported fixtures plus the compiler-bridge tests
Clone-safety-aware AU3005 indexed-read guidance, so the recommended recovery is never rejected in turn by AU3007	random_list_index_requires_transfer, random_transitive_dict_index_requires_transfer, generic_list_index_clone_safety_guidance, and generic_dict_index_clone_safety_guidance fixtures, the random_index_remove_transfers_ownership transfer fixture, and the compiler-bridge propagation test
Dedicated AU2007 builtin function redefinition code, distinct from the AU2006 builtin method collision	builtin_function_names_cannot_be_redefined fixture
Access-kind-specific AU3002 recovery help, naming the read, mutation, or consumption that actually conflicts	nested_consume_and_borrow_same_call, call_own_then_projected_copy_read_rejected, and binary_left_borrow_rejects_later_mutation fixtures
Current class-field-default callable limit	class_field_default_user_function_not_supported fixture
Retained non-copy binary/index/method-receiver/call-argument/indexed-assignment borrows, nested-consumption containment, AU3002 overlap rejection, and no hidden deep clone	binary_left_borrow_rejects_later_mutation, projected_binary_left_borrow_rejects_later_mutation, index_base_borrow_rejects_index_mutation, indexed_assignment_target_rejects_index_mutation, method_receiver_borrow_rejects_nested_argument_mutation, retained_receiver_nested_consumption_repro, retained_argument_nested_consumption_repro, method_receiver_rejects_nested_argument_consumption, and retained_parameter_rejects_nested_argument_consumption fixtures
Declaration-stable call/operator passing, directional exclusive-access checks, and the distinct task-capture boundary	generic_borrow_specialization_retains_copy_argument, call_borrow_mut_then_copy_read_rejected, call_own_then_projected_copy_read_rejected, trait_operator_borrow_mut_receiver_requires_mutable, trait_operator_copy_left_retains_borrow, trait_operator_own_receiver_moves_value, trait_operator_own_receiver_rejects_rhs_read, trait_operator_own_rhs_moves_value, trait_unary_operator_own_receiver_moves_value, operator_trait_value_receiver_snapshot, task_capture_snapshots_copy_arguments, and task_group_receiver_rejects_owned_variadic_capture fixtures plus the MIR/native parity matrix
One-time list/set own-iteration selection and Queue handle capture without source-binding retargeting	own_iteration_captures_collection, queue_iteration_captures_handle, and the MIR/native parity matrix
Queue receive-item ownership, accepted bare iteration, rejected own/mut iteration modifiers, and progress after an earlier producer completes while CPU burners exceed the default worker count	queue_bare_iteration_ownership, queue_own_iteration_rejected, the maintained mut rejection fixtures, check_and_direct_backend_reject_queue_iteration_modifiers, and queue_iteration_consumers_complete_with_more_cpu_burners_than_default_workers on MIR and direct
Typed heterogeneous select: exact inference, ownership, cancellation-first/lowest-index arbitration, atomic registration, one winner, loser cleanup, cross-worker wakeups, nested generic payload typing, and MIR/direct parity	typed_select_* compiler/runtime tests, select_* fixtures and CLI tests, the maintained select example, compiler-bridge/editor coverage, and the forced-backend parity matrix
Builtin trait-method no-shadowing across every builtin target, inherited-default containment, and direct builtin precedence	builtin_queue_trait_method_collision, builtin_task_inherited_trait_method_collision, builtin_task_group_trait_method_collision, builtin_list_trait_method_collision, builtin_string_trait_method_collision, and builtin_file_trait_method_collision fixtures plus builtin_method_names_cannot_be_shadowed_on_any_builtin_target and direct_backend_prefers_builtin_handle_member_if_collision_reaches_mir
Fixed 256 MiB filesystem, 64 MiB stream/TLS-configuration, and 16 MiB incoming HTTP limits	injectable-limit and sparse-file tests in src/runtime_value_tests.rs plus MIR/forced-direct filesystem and HTTP tests in crates/aura/tests/cli.rs
module and package resolution, module aliases, per-entry from-import aliases, canonical target identity, alias visibility/collisions, and alias-aware analysis	crates/aura-compiler/tests/modules.rs, tests/packages.rs, src/package_tests.rs, the import_aliases parity fixture, examples/modules/import_aliases.au, and compiler-service/LSP alias tests
MIR semantics and runtime behavior	src/mir_tests.rs, src/mir_runtime_tests.rs, tests/fixtures/run-pass, tests/fixtures/run-fail
native semantics and resource ABI	src/native_codegen_tests.rs, src/native_runtime_tests.rs, tests/native_runtime_ffi.rs
MIR/native observable equivalence	crates/aura/tests/backend_parity.rs
CLI, entrypoints, diagnostics, and installed builds	crates/aura/tests/cli.rs, crates/aura/tests/packages.rs
analysis, completion, hover, definitions, invalidation	tools/aura-language-server/test
maintained examples	compiler example smoke tests and CLI product tests

The exact repository gate is npm run ci. It runs formatting, Rust tests, backend parity, language-server and extension tests, compiler and LSP coverage gates, the documentation build, dependency audits, Clippy with warnings denied, and repository hygiene.

Fixture Classes

Each compiler fixture directory has its own contract:

• parse-pass: source MUST form a valid AST. Later static checking is not implied.
• parse-fail: source MUST be rejected during lexing or parsing with the stored diagnostic.
• check-pass: source MUST parse and satisfy the static semantics.
• check-fail: source MUST parse and then be rejected by static checking with the stored diagnostic.
• run-pass: source MUST check and produce the stored standard output through the maintained execution path.
• run-fail: source MUST check far enough to reach the intended runtime failure and produce the stored diagnostic behavior.

Regression tests supplement fixtures when a case needs multiple files, temporary packages, local sockets, processes, timing, cancellation, or a comparison of execution backends.

Backend Equivalence

Aura 0.6 has two maintained semantic runtime representations:

• aura run lowers checked source to MIR and executes it in the MIR runtime.
• aura build lowers checked source to native code through the direct backend and links the native runtime.

For the maintained source subset, the two paths MUST agree on:

• standard output and integer exit status
• return values and pattern results
• checked arithmetic and collection failures
• move/borrow-sensitive mutation and writeback
• place/view identity, returned provenance, reborrowing, immediate mutable write-through, closure-loan calls, and exit cleanup
• eager comprehension order, ownership, target scope, and partial-result cleanup
• owned list/str slice endpoint order, bounds failures, Unicode scalar selection, clone safety, and source/result independence
• with cleanup order and primary runtime diagnostics
• complete structured runtime diagnostics, including typed call frames and task ancestry
• task, queue, cancellation, process, filesystem, and network outcomes within platform constraints

The parity matrix runs every eligible runtime fixture through both paths. It compares complete diagnostics and does not mask backend-specific frame notes. A fixture may be excluded only through the explicit exclusion list. Each exclusion needs a reason that matches an intentional harness or platform boundary, not an unexplained semantic divergence.

Documentation Conformance

The build does not execute or hash-check the examples in the Manual or the tutorials. The evidence for a rule is the compiler fixture, regression test, or maintained example listed in the Executable Reference Map. The documentation build checks links and rendering.

A Manual fence label records the example's intended outcome: aura check-pass, aura check-fail:<code>, or aura fragment. A python fence means Python and is never Aura.

A Manual page is either a feature page or a structural page. A structural page organizes cross-cutting contracts. A feature page has these non-empty level-two sections:

• Grammar
• Typing Rules
• Runtime Semantics
• Ownership And Evaluation Order
• Diagnostics
• Backend Support
• Limits And Implementation-Defined Behavior
• Status

The Diagnostics section names each applicable stable AU code. If a feature introduces no feature-specific diagnostic, the section states exactly No feature-specific diagnostics. instead. That sentence is an explicit claim. It does not permit omitting general diagnostics that apply to examples on the page.

Language-facing changes still require compiler fixtures or maintained examples, as AGENTS.md directs.

Adding Or Changing A Rule

A language or tooling behavior change is complete only when the same pass updates, where relevant:

1. a failing compiler, runtime, CLI, or LSP test
2. the implementation
3. the normative Manual page and grammar when syntax changes
4. the API Index when public APIs change
5. Current Limits when a boundary is added or removed
6. categorized examples and Learn/tutorial material
7. the task board and dated work note

Each new construct needs an explicit compatibility decision. Being easy to parse is not enough.

Deriving A Book

A book may treat this reference as its factual source. It may introduce concepts in a different order, add motivation, diagrams, exercises, and larger examples, or leave advanced details out of early chapters. It must keep these constraints:

• every taught syntax form appears in the complete grammar
• every claimed type or ownership behavior agrees with the static semantics
• every runtime/API claim links back to a maintained contract
• proposal-only features are labeled as future design, not current Aura
• examples are compiled or run as part of the maintained repository surface

This split lets the reference stay precise while the book stays readable.

Design Record

• ADR-0017: Iteration source selection
• ADR-0032: Guarded lightweight-task stacks
• ADR-0033: Structural Transfer and task-result consumption
• ADR-0034: Typed heterogeneous select
• ADR-0035: Configurable blocking-I/O pool
• ADR-0036: Native structured runtime frames
• ADR-0037: Expression closures and value capture
• ADR-0038: Place-based loans and views
• ADR-0039: Comprehensions
• ADR-0040: Owned Vec and String slices
• ADR-0041: Contiguous numeric arrays and explicit integer arithmetic modes
• ADR-0043: Unified int64 index domain
• ADR-0044: Canonical collection surface
• ADR-0045: Testing framework and assertion introspection
• ADR-0046: String literal forms and f-string format specifications
• ADR-0047: Integer literal bases, bitwise operators, and shifts
• ADR-0048: Power, rounding, divmod, and the math module
• ADR-0049: Match guards and or-patterns
• ADR-0050: Module-level constants and deterministic initialization