PROGRESS MATRIX

This page tracks current implementation and target status for Moth's accepted design. Accepted deferred surfaces may appear here. Open design questions and outside-scope mechanisms do not. Permanent language exclusions live in Design scope.

Invalid-form diagnostic coverage may appear inside the row for the intended feature. This page is not a full language reference, roadmap, exclusion inventory or test manifest.

The compiler and memory design references may describe accepted end-state architecture that has not fully landed. This matrix determines what the compiler supports today.

Use this together with tests/cases/manifest.toml when changing language features.

How to read and edit this page

Alpha target

The supported Alpha target is:

Status legend

Status Meaning
Supported Implemented for the Alpha surface and expected to compile, type check, lower, and run through the JS / HTML pipeline.
Partial A useful subset is implemented, but some sub-surfaces are intentionally deferred, target-gated, or still being shaped before Alpha.
Experimental Present in the repo, but not part of the Alpha stability promise.
Deferred Planned or design-compatible, but not part of the current implemented Alpha surface.

Coverage legend

Coverage Meaning
Broad Multiple focused cases exist, including success and failure coverage.
Targeted Dedicated coverage exists, but not across all important edges.
Thin Coverage exists indirectly or through only a small number of cases.
None No clear canonical coverage found.

Core Alpha surface

Surface Status Coverage Runtime target Notes
Entry-selected module roots and implicit start Supported Broad entry-selected start, dependency-sort, normal-file top-level rejection, imported-root suppression, fragment-order, and API-only artifact-filtering coverage. Frontend / HTML builder Selected normal modules compile dormant compiler-synthesised start work. Entry assembly activates an entry-selected module's start exactly once. Imported roots expose public interfaces without activating root work. API-only roots remain dependency-bindable and emit no HTML page artefact. The implicit start function is build-system-owned and not user-bindable or callable.
Structured diagnostics Supported Broad dependency, config, project-structure, syntax, type, rule, borrow, backend-feature and warning coverage plus targeted compiler-owned reason and primary/secondary source-remapping assertions. Frontend User-facing failures use typed CompilerDiagnostic payloads with stable codes and optional qualified reason keys. Integration expectations consume that identity and fixture-relative source locations without reconstructing payload taxonomy. Infrastructure and invariant failures use CompilerError. Type diagnostics are TypeId-first at semantic boundaries.
Variables, assignment and lexical scope Supported Broad declaration, reassignment, mutability, structured-control-flow scope, shadowing, undefined-mutation and diagnostic coverage. JS / HTML Mutable writes require mutable places. There is no dedicated general lexical-block construct and no control-flow labels. Structured control flow owns lexical scope, and statically selected Bool branches retain their authored child scope while disappearing before HIR.
Control flow Supported Broad parser, HIR, integration, dispatcher, branch, loop, break, continue, and match lowering coverage. JS / HTML Branch-heavy CFG cases and loop exits remain important regression surfaces.
Assertions Partial Broad parser, diagnostics, HIR lowering, backend artifact, and integration coverage. Frontend / HIR / JS / HTML assert is a statement-only language intrinsic. It is always checked, unrecoverable, and accepts named/default typed messages. JavaScript and HTML evaluate reachable runtime messages lazily on the failure edge; HTML-Wasm accepts default, fully folded and unreachable literal-true runtime messages but rejects reachable runtime construction. Literal-true messages are fully type/generic/evidence checked and normalized, then replaced with typed none before HIR, so no TIR, runtime handoff, reactive metadata, generated request or executable fact is published. Message construction cannot escape its evaluation through !, ?, return, break or continue. Authored propagation locations remain distinct from ordinary call mapping. assert(false) is statically terminal.
Functions and calls Partial Broad declaration, terminality, call validation, named and positional arguments, defaults, parameter passing, external calls, and return coverage. Frontend / JS / HTML Named calls and defaulted parameters are supported. Non-unit success-return functions are validated for all-path terminality before HIR. External and compiler-owned builtin calls remain positional-only. Source-authored return-alias syntax has been removed. Ordinary return preserves allocation identity, explicit copy creates independence, and each call result receives a separate caller binding. Current multi-return alias analysis may conservatively over-approximate relationships between returned values, which can produce stricter alias diagnostics.
Default arguments and field defaults Supported Broad function parameter default, struct field default, named-call default skipping, constructor default skipping, and diagnostics coverage. Frontend / JS / HTML Function parameters and struct fields can define defaults with =.
Templates and style directives Supported Broad template parsing, directive, slot, const/runtime fragment, template control-flow, markdown inline-code, diagnostics, and JS/HTML integration coverage. Focused $code formatter, escaping, lexical-role and HTML artifact coverage. HTML / JS Main Alpha surface. Supported shapes include const and runtime templates, slots/inserts, $children / $fresh routing, markdown/code/raw/html/css/escape directives, template Bool and option branching, template loops, runtime slot applications, dependency namespace member access in template heads and const expansion guards. Post-TIR performance follow-ups remain accepted deferred implementation tracked below and in the roadmap. $code("moth") uses compiler-owned current word classification, lexical token roles and shared code presentation classes, and performs no semantic symbol resolution. Stateful template-body-aware suppression stays a deferred roadmap follow-up.
Moth template .mtf content assets Partial Targeted compiler-integrated dependency binding, synthetic content constant, markdown folding, module-root re-export, direct API, diagnostics and integration coverage. HTML builder / frontend .mtf files are builder-supported source assets that synthesize one private compile-time content #String constant from an implicit $md template body. Nested templates with no explicit directive also default to $md, and any explicit nested directive overrides that default. They bind extensionlessly into .moth, can be re-exported through a module root's export: block, and must fully fold. Same-directory constants and builder constants remain visible when their names are unique. A collision reports both source locations where available, and neither source shadows the other.
Plain Markdown .md content assets Supported Broad extensionless dependency, direct alias, module-root re-export, parser options, raw HTML, literal links/images, collision, direct-extension and module-root rejection coverage. HTML builder / frontend .md files are plain Markdown content assets that render to HTML at compile time and synthesize one private content #String constant. They do not parse Moth dependency clauses, declarations, interpolation, templates, frontmatter, metadata or same-directory module-root scope. Links/images render literally and are not resource outputs in V1.
Builder-supported source file kinds Partial Targeted moth template and Markdown source-kind registry, extensionless resolution, unsupported-kind diagnostics, source discovery, and tokenizer/preparation coverage. Stage 0 / frontend Builders can declare non-.moth source file kinds that participate in source dependency discovery and frontend preparation. The HTML builder implements moth template .mtf and plain Markdown .md content assets.
Structs, records, and receiver methods Supported Broad parser, constructor, default, receiver, cross-file, borrow, and diagnostics coverage. JS / HTML Source-authored receiver methods are statically resolved and belong to the same file as their nominal receiver type. External packages do not expose receiver methods.
Choices Supported Broad declaration, constructor, dependency, return, assignment, match, payload, JS carrier-shape and structural equality coverage. JS / HTML Unit and record-payload variants are supported. Payload fields are immutable. Accepted incomplete work includes direct payload field access with narrowing, nested payload patterns and recursive choices.
Pattern matching Partial Broad literal, choice-match, payload-capture, relational pattern, guard, exhaustiveness, warning, diagnostics, and single-predicate value-if coverage. JS / HTML Literal patterns, choice variants, payload extraction, relational patterns, guards, and else => arms are supported. General bare-name capture has been removed from full-match positions, and String relational subjects are rejected. Option |name| and declared choice payload captures remain valid. Inline and block option-present and choice-predicate single-predicate value matches are supported at closed receivers, with focused coverage. Full relational overlap analysis and nested choice payload patterns remain deferred. Relational subjects are limited to Int, Float and Char.
Collections Supported Broad literal, mutation, builtin method, indexing, loop, result, fixed-capacity, fixed overflow and catch, growable handling rejection, AST/HIR, JS helper, and diagnostics coverage. JS / HTML Growable {T} and fixed {N T} collections are distinct semantic types. Fixed capacities accept positive literals or bare visible #Int constants. Growable push is infallible, returns no value and rejects catch and postfix !; allocation exhaustion traps or aborts rather than entering Error!. Fixed push is fallible only when the collection is full and reuses the existing capacity error. get, set and remove stay fallible, and length stays infallible. One source spelling resolves push from the receiver's collection shape in the AST, HIR lowers distinct call targets, and the JS runtime exposes separate growable and fixed helpers. HTML-Wasm collection lowering remains deferred and target-rejected.
Hash maps Partial Broad frontend, HIR, borrow, JS, backend-validation, diagnostics, and integration coverage. JS / HTML / backend validation for other targets V1 supports insertion-ordered scalar-keyed maps with {K = V} types, map literals, compiler-owned map members, borrow validation and JS runtime lowering. HTML-JS normalizes every String-like key to canonical content, including template-backed keys. Non-JS map lowering remains the primary accepted target gap.
Results, options, multiple returns, and multi-bind Supported Broad option, fallible return, postfix propagation, catch, value-producing block, multi-return, multi-bind, and diagnostic coverage. JS / HTML Error!, postfix !, catch, value-producing blocks, options, multiple returns and multi-bind are supported. Value-producing if and match work at declaration, assignment, return and multi-bind receivers. Nested then receivers remain deferred.
Constants and compile-time folding Supported Broad top-level constant, dependency sorting, template folding, numeric folding, const-record, anonymous const-record, external constant, config, and diagnostics coverage. Frontend Top-level compile-time constants such as name #= value must fully fold. Same-file constant evaluation follows source order unless dependency sorting can order top-level declarations. Const records are compile-time field-access-only values. |...| in a compile-time receiving context is an anonymous const record: every parameter needs a value, the list does not declare a constructable type, and nested lists are declared first then named. Exported and imported folded records are supported.
Type aliases Partial Broad builtin, imported, collection, option, generic instance, alias-to-alias, remap, fixed-capacity constant, trait-requirement, and diagnostic coverage. Frontend Transparent aliases to builtins, source and imported source types, collections, maps, options and concrete generic instances are supported, including targets whose fixed collection capacity folds a module constant. Alias targets keep local nominal identity through generic materialisation. The compiler still rejects aliases to external opaque types despite the accepted transparent-alias contract.
Arithmetic, explicit casts, and copy Partial Broad arithmetic, precedence, checked numeric, cast parser/AST/HIR/JS, const-folding, explicit copy, and diagnostics coverage. JS / HTML Runtime numeric operations lower through checked HIR operations. Explicit cast uses compiler-owned builtin cast policies and evidence. Scalar constructor-style conversions are removed. Const Error materialization, branching const catch handlers, and Wasm cast lowering remain deferred.
Float formatting and boundary validation Supported Targeted stable formatting, finite-source, external-boundary, HIR statement, JS helper, and validator coverage. JS / HTML Moth-owned Float formatting is used for AST folding, runtime template interpolation, and casts. External Float success returns are validated before ordinary Moth code observes them.
Type checking and coercion Supported Broad type compatibility, contextual promotion, strict expression typing, call argument, return, declaration, and diagnostics coverage. Frontend Strict expression typing stays separate from contextual declaration, return, parameter, template/string, and explicit-cast boundaries.
Traits Partial Broad declaration, conformance, visibility, generic-bound receiver-call, trait-name rejection, core cast trait metadata, incompatibility metadata, public API leak, and diagnostics coverage. Frontend static semantics Static trait declarations, explicit same-file nominal conformances, reusable evidence, trait incompatibility metadata and generic bounds are implemented. Accepted incomplete work covers static non-method requirements, additional compiler-owned builtin conformance families and a broader standard trait taxonomy that remains static.
Strings, coercion and IO/template boundaries Partial Broad quoted-escape, string-content coercion and IO/template rejection coverage, plus targeted external StringContent signature coverage. Frontend / JS Quoted strings decode only \\, \", \n, \r and \t. Invalid escapes are rejected by the tokenizer. Template heads and reusable external string-content signatures accept supported string values. Console helpers such as io.line(...) use the same boundary, so complex values must be extracted or interpolated into templates before output. AST rejects source String + String and no longer folds compile-time string addition. Runtime equality compares String content across construction origins; HTML-JS normalizes String-like map keys and HTML-Wasm compares finalized string bytes. Accepted design rejects source string concatenation with +; templates remain the canonical concatenation form.
Borrow validation and local last-use analysis Partial Broad borrow, aliasing, mutable/exclusive access, branch merge, loop, short-circuit, future-use, optional-transfer, advisory drop-site, hashmap, aggregate-storage, reactivity and adversarial coverage. Phase 1 establishes the permanent `boracle` developer feature, shared `problem` and `last_use` seams and an opt-in `just boracle` validation lane. The reference facility now extracts validated HIR into immutable normalized problems, constructs typed `OriginRelations` as the only origin-overlap owner, answers pair-local `query_overlap` decisions with positive disjointness evidence and derives alias/provenance loans that retain structural place overlap separately. It connects parameter-aware origin flow to use-driven liveness, origin/loan last-use and exact after-event final-use candidate queries. Its compiler-owned source service covers calls, aggregates, maps, fallible flow, branch/loop paths and bounded generated copy/rebind metamorphic properties with deterministic reduced failure reports and classified comparisons against the deliberately shared Alpha subset. Composable experiment selection uses `boracle-reference-v1` with a sorted empty-by-default experiment set; the only current named experiment, `dead-exclusive-loan`, remains feature-gated developer research and is not production language support. A second executable semantics, the bounded operational oracle, now executes the same normalized problems with explicit dynamic generations and capability intervals, enumerates branches and bounded loops deterministically, always reports truncated exploration as inconclusive and classifies its result against the static solver so static acceptance plus an enumerated runtime conflict is a required failure. A seeded generator and a class-preserving reducer turn generated disagreements into minimal reproducible cases. The oracle is feature-gated developer reference infrastructure and never user-facing borrow support. The alpha checker remains the normal compiler authority; Boracle never changes default acceptance. Lifetime-region validation, retained-edge analysis, REC integration, memory-plan-driven cleanup and the optimized production checker remain deferred. HIR analysis / all backends Shared and exclusive access enforcement is implemented and mandatory on every backend. Path-sensitive future-use facts drive optional transfer, and unproven or path-dependent transfer correctly falls back to borrowing. Per-block future use is a liveness fact, so an alias that every path redefines before its next read stops blocking mutation, including across a loop back-edge. Accepted incomplete work: loop final-iteration facts, detached stored-result transfer and the complete affine-transfer contract are not implemented, and drop facts remain advisory rather than memory-plan-driven. Complete when path-sensitive transfer and final-use facts are complete.
Result provenance and retention summaries Partial Targeted return-alias and fresh-result summary coverage. HIR analysis / link planning Public summaries currently distinguish fresh result roots, parameter aliases and an imprecise unknown case. Accepted incomplete work: projection results, detached stored results, result-to-result aliases, independent result graphs, retained-parameter and outlives constraints, retention and cardinality effects, whole-domain kill effects, outcome-sensitive effects and frontier-enabling effects are not exported yet. Complete when stable complete summaries cross module and package boundaries with no unknown topology-relevant provenance.
Lifetime-region and escape validation Deferred None Backend-neutral design Accepted architecture exists; no implementation owner has landed. This validation is mandatory in the accepted design, and no backend or profile may bypass it. Complete when mandatory local and link topology proof is implemented.
Retained-edge liveness and cleanup frontiers Deferred None Backend-neutral design Accepted design only. Covers retention domains, edge creation, whole-domain kill effects and path-sensitive final cleanup frontiers. Builtin collections do not yet expose `clear` or compiler-known retention effects outside maps. Complete when whole-domain effects, frontiers and epochs are implemented.
Compiler-generated intervals and region epochs Deferred None Backend-neutral design Accepted design only. Inferred regions must be non-lexical CFG intervals rather than lexical scopes, with repeated population and teardown forming region epochs. Complete when non-lexical interval inference and epochs are implemented.
Declared regions (`name:` / `into name`) Deferred Targeted lexer, statement-classification, deferred-diagnostic, anonymous-declared-region rejection and reclaimed-identifier coverage. Frontend / HIR / lifetime analysis / all backends Valid name: headers are reserved in executable statement position and report a deferred-feature diagnostic. Exact _: is rejected. Full declared-region parsing, into name placement, HIR metadata, topology and backend support remain deferred. Declared regions are hard count-free bulk lifetimes whose owned storage is never released individually.
Direct source-created reference cycles Deferred None Frontend / lifetime analysis / all backends Accepted design only. A declared region is the only source mechanism for reference cycles, and inferred-region analysis never invents a cyclic region. Complete when direct source-created cycle construction and bulk cleanup are implemented.
Affine Ownership ABI Experimental Targeted Wasm ownership-projection and conditional-drop coverage. Wasm Present but not part of the Alpha stability promise. Borrow-checker advisory drop sites currently emit Wasm DropIfOwned directly under current scaffolding, and the LIR carries a reserved retain instruction. This direct path is migration debt, not accepted final architecture. Complete when memory-plan-driven full-control lowering replaces it.
Memory-strategy planning Deferred None Backend-neutral design Accepted design only. A distinct compiler-owned planner must select stack, inline, affine, inferred-region, declared-region, REC or host garbage-collected representation per allocation family after topology is proven, and must also produce the concrete per-family obligation transitions the backend encodes. A missing strategy after successful validation is a `CompilerError` in the accepted design. No `ValidatedMemoryPlan` implementation owner exists yet. Complete when the planner owns every strategy decision and its plan is validated before lowering.
REC analysis and selection Deferred None Backend-neutral design Accepted design only. Retained Edge Counting is a compiler-selected physical representation for runtime-many persistent retained edges, never source semantics. The canonical contract lives under `docs/src/developer-docs/memory-management/retained-edge-counting/`. Complete when the companion analysis and its decision reporting are implemented.
REC backend lowering Deferred None Full-control backends Accepted design only. Covers the two-bit tagged handle ABI, selective inline counters, count transitions and iterative destruction. Complete when tags, counters, collections and iterative destruction are implemented.
Field-sensitive allocation splitting Deferred None Backend-neutral design Accepted design only. Projections currently remain rooted in their containing allocation family. Complete when split analysis and strategy rerun are implemented.
Inferred-region and declared-region backend lowering Deferred None Full-control backends Accepted design only. Wasm runtime memory currently provides basic linear-memory page and heap-base planning with no allocator, inferred-region, declared-region or destruction-plan support. Complete when inferred-region allocation with complete exits and declared-region bulk cleanup are implemented.
Physical coalescing Deferred None Backend-neutral planning / full-control backends Accepted optional optimisation only. Physical coalescing may keep storage slightly longer than the maximally precise semantic interval, but it never widens semantic topology or changes diagnostics. Complete when the narrow straight-line heuristic is implemented and verified.
Builder lifecycle regions Deferred None Project/link planning / full-control backends Accepted design only. Page, mount, request, frame and arena roots must participate in ordinary lifetime-topology validation for reactive and mounted storage. Complete when builder lifecycle roots instantiate validated topology and memory plans.
Collector-free release verification Deferred None Full-control backends / project builders Accepted design only. Backends must declare collector-free release capability, and a capable backend must not fall back to a tracing collector. This is a backend capability and an artefact property, never a source-visible or project-visible mode. Complete when a capable backend proves no tracing runtime remains.
Channels Deferred None Async / lifetime planning / full-control backends Accepted prerequisites are mandatory affine transfer on successful send, responsibility preservation on failed send, bounded channel or task lifetimes, independent graphs across task boundaries and non-atomic REC under the cooperative task model. Complete when the final memory prerequisites and a separate channel implementation plan are accepted.
Debug and GC-native representation parity Partial Broad JS pipeline coverage; no cross-backend memory parity suite. JS / host GC The JS backend uses host collection for already-legal topology, which is accepted behaviour for a GC-native target. Accepted incomplete work: parity currently rests on borrow validation alone because lifetime-topology validation is deferred, so the shared legality guarantee is not yet fully enforced. Complete when debug, GC-native and collector-free paths demonstrably share source legality and observable behaviour.
WIT value-only component integration Deferred None Frontend / build / backends Accepted closed external-boundary profile; no current import validator or runtime integration.
Paths and dependency clauses Supported Broad source dependency, namespace, flat direct-selection, binding-backed package, public-surface, module-boundary, collision, continuation-diagnostic and legacy-import-migration coverage. Frontend / HTML builder Source and module namespace records are shallow. External package namespace records support nested symbol paths such as io.input.new and io.input.Input. Direct symbol-path dependencies remain rejected. Cross-module and source-backed package access goes through the target root's export: public surface.
File paths in value position Supported Broad prepared-reference and Stage 0 physical-input resolution, fixed-point content discovery, AST String/file-kind semantics, structural Resource/SiteRoot flow, public/generated/service boundaries, provider JS identity, output-link planning, boundary, symlink, missing-watch, config-rejection and ordinary user-defined Path coverage. Frontend / HTML builder Every physical-target-bearing non-dependency path token is classified during retained preparation and resolved once during Stage 0. Referenced .mtf and .md sources extend preparation to a fixed point; ordinary resources produce byte-free physical input and watch records; SourceKindNoFileValue for .moth plus extensionless and site-root rows remain no-physical-target outcomes for AST. AST interprets published outcomes as ordinary String values, including structural Resource/SiteRoot pieces. Direct .mtf compilation consumes the same Stage 0 facts, provider JS assets share resource identity and IO authority, and CSS validation preserves opaque anchors. Config bootstrap rejects file-value paths. The superseded source-visible Path type is gone, so Path is an ordinary user identifier.
Binding-backed platform packages Partial Broad package dependency, external constant, external signature, provider-created JS package, runtime asset/glue, core package, prelude and backend validation coverage. Frontend / JS Rust-side and provider-created binding-backed packages expose free functions, opaque types and compile-time scalar constants. Project-local and builder-owned annotated .js files can create JS-backed package surfaces. Binding-backed packages do not expose receiver methods. Unsupported reachable calls for an active backend fail before lowering.
HTML project builds Supported Broad routing, API-only artifact filtering, document shell, metadata, config, output cleanup, external JS glue, page-fragment and resource-output coverage. HTML / JS This is the release-critical project backend. Only roots with HTML artifact activity participate in page, runtime asset, resource-output and homepage planning. HTML-Wasm behavior is tracked under experimental surfaces.
Logical expressions Supported Broad precedence, grouping, invalid operand, not, comparison, short-circuit, and JS operator mapping coverage. JS / HTML Keep short-circuit behavior covered through artifact-shaped tests.
If statements and conditions Supported Broad condition validation, nested condition, Bool requirement, same-line else-if rejection, and JS lowering coverage. JS / HTML Conditions require Bool unless the specific syntax is an option or match-style selector.
Char Supported Broad success coverage with targeted diagnostic coverage. JS / HTML Additional malformed-char diagnostics are cleanup, not a core Alpha blocker.
Named arguments and call-site mutability Supported Broad function-call, constructor-call, duplicate, unknown, missing, ordering, and tilde diagnostics coverage. JS / HTML Fresh rvalues can satisfy mutable parameters without ~. Existing places still require explicit ~.

Core and builder packages

Surface Status Coverage Runtime target Notes
Prelude policy Supported Targeted prelude symbol registration, namespace-alias plumbing, and collision rejection coverage. Frontend / JS The builtin prelude policy registers io as a namespace alias to @core/io and leaves compiler-owned Error as a bare language symbol. There is no @core/prelude package.
Core IO package Partial Console helpers, prelude/explicit namespace dependencies, old callable rejection, removed public IO, input metadata/type-checking, HTML-JS input helper emission and backend unsupported-call diagnostics. Frontend / JS / HTML-Wasm validation @core/io exposes io.print, io.line, io.debug, io.warn, io.error, and io.input.*. The prelude injects io as a compile-time namespace alias, not a runtime value. Deferred IO domains such as filesystem, network, timers, event queues, targeted input sources, and non-JS lowerings belong in the roadmap.
Core math package Partial Targeted direct, aliased, namespace, const, arity, type, missing-symbol, unbound access, finite-result boundary and HTML-Wasm unsupported-path coverage. JS / HTML-Wasm validation @core/math exposes Float math functions and scalar constants. It requires an explicit dependency clause. HTML-JS routes every single-Float external result through the shared finite-result boundary, rejecting NaN and both infinities before ordinary Moth code observes them. HTML-Wasm has no lowering for this package.
Core text package Partial Targeted runtime, JS helper, arity, type-error, edge-case, unsupported-builder, and Wasm-unsupported coverage. JS / HTML @core/text exposes string helpers such as length, emptiness, containment, prefix, and suffix checks. HTML-JS text.length counts Unicode scalar values with the same unit as Char. Receiver-method forms and HTML-Wasm lowerings remain deferred.
Core random package Partial Targeted dependency, JS helper, runtime smoke, arity, type-error and Wasm-unsupported coverage. JS / HTML @core/random exposes random Float and inclusive random Int helpers. Seeded random and non-JS lowerings remain deferred.
Core time package Partial Targeted dependency, direct alias, namespace, helper, runtime smoke, fallible parse/catch, arity/type diagnostic, old-name rejection, opaque-field rejection and backend validation coverage. JS / HTML @core/time exposes opaque Duration, TimeMark, and Timestamp values plus the first JS-backed time helper slice. Calendar/time-zone APIs, timers, animation scheduling, and non-JS lowerings remain deferred.
Source-backed package roots Partial Targeted AST-backed config loading, known-key and shape enforcement, self-contained config dependency rejection, generic package-root discovery, collision detection and public-surface enforcement coverage. Frontend / HTML Source-backed packages and regular modules share module-root and visibility rules. config.moth is compiled as one self-contained source before package discovery and rejects every dependency clause before path resolution.
Builder-provided source-backed packages Partial Targeted builder source-backed package root registration and HTML Builder package coverage. Frontend / HTML Builders expose source-backed packages through BuilderSurface.source_packages. The HTML builder provides @html as a source-backed package. Builder and project-local prefix collisions are hard config errors.
Project config model Supported Targeted grouped-project-record validation, recursive builder-section schemas, direct and source #Config contracts, typed --input inference for build/check/dev, ordinary if static specialisation, immutable @project binding, provenance and package-boundary isolation, repeated dev input retention and origin-independent semantic fingerprint construction, self-contained dependency-clause rejection and legacy flat-key rejection coverage. Frontend / HTML The compiler accepts grouped config: one required open project record plus active builder sections such as html. Direct and source #Config values resolve to ordinary folded constants, and explicit @project exposes immutable project fields through the reserved synthetic interface. Typed --input values are shared by build, check and dev; ordinary static if consumes folded Bool values before HIR. Config values carry boundary-local provenance and origin-independent semantic fingerprints (name, contract type and effective value-or-absence) during frontend compilation. Those facts are not retained after the build; retention, dependency-aware targeted invalidation and reuse are deferred to the existing incremental and persistent artefact work. Consuming-project inputs do not satisfy dependency contracts. Retired flat keys (project #= "html", dev_folder, output_folder and package_folders) are rejected. Former top-level builder fields such as origin remain private helpers. Entry-local config: blocks remain deferred.
Project-local packages Partial Targeted structural support-package roots, rejected legacy package-folder configuration, independently registered builder packages, dependency resolution, generic normal module-root and public-surface coverage. Frontend / HTML Structural +*.moth support packages and the optional project-root facade define the accepted project-local package model. The legacy config-driven package_folders paths, including the historical default lib/, are deleted: the retired flat key is rejected and package discovery is purely structural. Independently registered Builder/Core source packages retain their own package boundaries. Each support package's containing directory supplies its name. Stage 0 requires exactly one direct @*.moth or +*.moth root with a non-empty cosmetic name. The filename after @ or + has no semantic role and the root's strict export: block defines its public surface.
Builder runtime packages Partial Targeted built-in JS-backed package, runtime asset, runtime module, import-map, glue, and backend validation coverage. HTML / JS Builder-owned runtime packages such as @web/canvas are binding-backed packages. They share the specialised external package registry and HTML external JS asset/glue pipeline with provider-created imports.

Compiler-owned builtin surfaces

Surface Status Coverage Runtime target Notes
Collection methods Supported Broad JS helper, split growable and fixed push helpers, fallible get/set/remove and fixed push, infallible growable push and length, growable handling rejection, fixed overflow, removed indexed-write, bounds, and mutable-receiver coverage. JS / HTML Collection get, set, push, remove, and length are compiler-owned members. Mutating calls, including both push forms, require explicit mutable receiver access. One source spelling push(value) resolves from the receiver's collection shape: growable push is infallible and rejects ! or catch handling, while fixed push is fallible only when the collection is full and requires ! or catch. The JS runtime exposes separate growable and fixed helpers; HTML-Wasm collection lowering remains deferred.
Receiver methods Supported Broad same-file struct/choice receiver, aligned generic receiver, imported generic receiver, namespace receiver type, module-boundary exposure, nonlocal/builtin/external receiver rejection, duplicate, collision, and mutability coverage. JS / HTML Source-authored receiver methods travel with receiver type visibility, including retained generic receiver templates across module and package boundaries. They are never selected independently, aliased or exposed as namespace-record fields.
Fallible suffix handling Supported Broad propagation, shared then catch recovery, catch handler, template-boundary, explicit HIR branch, direct-return, call-argument, receiver-base, match-guard, and obsolete HIR propagation-expression removal coverage. JS / HTML Fallible calls lower through explicit success/error HIR control flow. Value-producing catch recovery uses shared value-block result locals. Collection and map fallible members use the same path.
Builtin Error type Supported Constructor, default-field, named-argument, public field, and backend-generated Error coverage. Frontend / JS Public fields are message and code. Hidden location/trace metadata remains backend-internal.

Reactivity V1

Surface Status Coverage Current surface
Reactive declarations and parameters Partial Frontend syntax, AST/HIR metadata, borrow invalidation facts, JS lowering, HTML-JS mounting, and unsupported sink/backend diagnostics. V1 supports $Type / $= local declarations and $T parameters as source metadata, not wrapper TypeIds. Reactive declarations are runtime-local and not dependency-bindable/exportable top-level declarations.
Reactive template subscriptions Partial Template-head parsing, source validation, subscription metadata, AST/HIR propagation, reachability, borrow invalidation, JS helper lowering, HTML-JS mounting, and unsupported sink/backend diagnostics. V1 accepts one bare reactive source identifier in template head/capture positions through $(source). Snapshot reads remain ordinary captures. Field paths, calls, computed expressions, ordinary expression use, and compile-time templates are rejected.
HTML-JS reactive runtime fragments Partial JS reactive source, scheduler, template-string runtime helper, slot mounting/rerender registration, and unsupported sink coverage. V1 live sink support is top-level runtime HTML fragments in the HTML-JS builder. Fine-grained DOM updates, nested live regions, keyed diffing, and other UI runtime strategies are deferred.
Reactive follow-ups Deferred No accepted syntax beyond V1 source subscriptions. Deferred surfaces include reactive-aware template control flow, field/path subscriptions, collection item subscriptions, expression dependency tracking, derived reactive values, live IO sinks, template-owned event/action/effect syntax, $bind, typed component messages, and HTML-Wasm reactive runtime support.

Experimental backend surfaces

Surface Status Current role Alpha rule
HTML-Wasm Experimental Backend experiment and integration path for future Wasm output. Ordinary entry-selected `start` execution and non-reactive runtime page fragments use the shared HTML builder slot/hydration contract. Reactive mounting remains unsupported. Keep behind --html-wasm. Tests may pin current behavior, but Alpha support is JS / HTML.
Wasm backend Experimental Long-term backend direction with current HIR-to-Wasm-LIR lowering, runtime contracts, request validation, debug output, and binary emission work. Do not count Wasm support as an Alpha blocker except for clean diagnostics and no-panic guarantees on covered paths.
Wasm payload/runtime parity Experimental Covered paths validate or lower selected payload, assert, generic, map, collection, numeric, cast, reactive, and external-call cases. Backend parity progress belongs here, not repeated in every feature row.

Compiler implementation and tooling

Surface Status Coverage Current status
Frontend Arena + Semantic Invariant Optimisation Partial Broad benchmark, profiling, adversarial-fixture, scope-frame, capacity-estimate, and validation coverage. Implemented pieces include frontend token/header stats, conservative capacity estimates, AST-owned scope-frame arenas, production scope-arena seeding, external package registry clone reduction, and adversarial benchmark fixtures. Broader expression, template/render-plan, HIR, bump-allocation, and persistent-cache migrations remain deferred until profiling justifies them.
Static Bool if specialisation Implemented Frontend pipeline, HIR boundary, terminality, branch scope, inactive diagnostics and generated-request coverage. Both branches remain frontend-valid. A known Bool selects one compiler-generated lexical scope before terminality, durable generated work and HIR. Runtime conditions retain ordinary branch lowering, and source structure never depends on the condition.

Accepted deferred and incomplete surfaces

Surface Status Coverage / diagnostic direction Notes
Post-TIR template performance follow-ups Deferred Not part of the current Alpha surface. Deferred items are source-span-backed template body text, a per-template parse cache, a formatter-output cache, dev-mode source-hash keyed template reuse, dependency-aware invalidation for imported consts/directives, formatter algorithm rewrites if profiling justifies them, incremental module/template compilation after module-boundary incremental builds exist, and parallel nested-template folding after a separate profiling-backed plan.
Range values outside loop headers Deferred Loop-header ranges are covered with the loop surface. One targeted case pins that a folded Range constant survives to HIR; the operations a range would need are not covered because they do not exist yet. start to end is a loop-header form today. A Range can be bound - including as a # constant, which folds and lowers - but the bound value is inert: it is not a collection-loop source, exposes no start / end members and is not renderable in a template head. First-class range values are intended but not designed or implemented, so do not add coverage for range operations until the surface is shaped.
Choice payload field access Deferred Targeted direct-field-access diagnostic coverage. Use pattern matching to extract payload fields until variant narrowing/refinement is designed.
Choice nested payload patterns and richer exhaustiveness Deferred Targeted nested-pattern deferred diagnostics. Exhaustiveness is tag-level for now. General pattern binding renames are also deferred outside choice payload capture renames.
Choice recursive types Deferred Targeted recursive declaration deferred diagnostics. Requires layout and indirection design.
`as` keyword domains Supported Targeted success and invalid-position diagnostics. as is valid for type aliases, dependency namespace/direct-selection aliases, and choice payload capture renames. Other positions are rejected.
Module-root export/re-export syntax Supported Targeted authored export, flat direct-selection re-export, alias, source/external symbol, privacy, duplicate, placement, and strict-block rejection coverage. A module root's single strict export: block exposes public authored declarations and flat dependency re-exports. Legacy inline export forms, bare namespace exports, wildcard exports, function alias values, and automatic method re-export through type aliases are rejected.
Source-backed package HIR caching Deferred No precompiled source-backed package cache. Source-backed packages are compiled from source each build. Caching is deferred until the package system is stable.
Package manager Deferred No package manager, remote registries, lockfiles, or dependency resolver. Package management, versioning, lockfiles, and remote fetching remain roadmap work.
External JS package expansion Deferred JS provider diagnostics reject unsupported public binding forms. The HTML builder supports annotated single-file .js imports and builder-owned JS-backed packages. Accepted future binding work includes generic external functions and types.
Generic type infrastructure Supported Broad TypeId, nominal instance, alias, constructor, dependency, HIR validation, trait-bound and diagnostic coverage. Generic structs, choices, concrete aliases, generic free functions, aligned generic receiver methods, and trait-bound validation use canonical TypeId identity before HIR.
Generic functions Partial Broad declaration, body validation, inference, instantiation, module-boundary dependency, frozen provider semantic-closure defaults and namespaces, nested private receiver materialisation with forwarded receiver bounds and evidence, diagnostics, fallible return and non-value-use coverage. Generic free functions and aligned receiver templates infer from immediate call arguments and immediate expected result context only, then emit concrete instances before HIR. Explicit call-site type application is not part of the current inference-only rule.
Trait bounds on generics Partial Broad declaration-site bound, visible evidence, module public-surface privacy, receiver-call, nominal generic instance, and negative diagnostic coverage. Bounds use is. Concrete generic calls and nominal generic instances require visible reusable evidence.
Recursive generic types Deferred Targeted recursive generic type diagnostics. Requires layout and indirection design.
Nested generic type application Deferred Targeted nested of diagnostics and alias workaround coverage. Name intermediate concrete aliases instead of writing nested inline generic applications.
Generic external package functions Deferred External signature validation rejects unsupported generic external surfaces. External packages currently expose concrete functions, opaque types, and constants only.
Rich numeric redesign Deferred Current numeric coverage is tracked in the core arithmetic and Float rows. The accepted Number and fixed-scale NumberN family, Byte scaffold and conservative numeric check elision remain deferred. Byte runtime support and lossy Float/Number helpers remain later accepted work.

Maintenance rule

This matrix should stay concise and current.