Skip to content

Maintained Lucid suite

This maintained Rust end-to-end suite uses frozen templates and independent expected bundles. The result ledger records verification for a specific source identity and host.

The current runner contains the following obligations:

BoundaryRequired coverage
Complete AML generation59 applications, with all 295 returned artifacts compared exactly.
Malformed composition192 stored inputs: 62 callable, 35 selection, 50 iteration, five empty-composition, four Deferred, two invocation, 14 keyed-GI and 20 generic/lifetime cases.
Native compilation59 Expected and 59 Generated contracts; each phase requires 45 successful builds and 14 specific intentional Rust errors.
Frozen definitionsAll 18 selected Rust segment assets match their recorded hashes.
Focused generic/lifetime checks50 exact primitive profiles, plus lookup, preparation, placement and resource/isolation checks.

Shared interpreter, provenance, primitive, preparation and resource/isolation tests supplement these complete-application obligations. The 50 profiles above are the generic/lifetime additions, not the total number of low-level suite tests. Native checks compile the Expected and Generated contracts; three positive future cases also execute generated assertions. Deployment scripts remain unexecuted.

This guide owns the current inventory and commands. The dated ledger owns observed generation, native compilation and acceptance results. The sections below describe each family's composition, rejection and isolation obligations.

Frozen templates and retained shared tests

Section titled “Frozen templates and retained shared tests”

templates.sha256.json records the repository-relative paths and SHA-256 hashes of the 18 Rust segment files. The freeze check compares the selected resource files against those hashes; there is no automatic update mode. The Rust reference defines the supported forms, excluded Deferred interface and integration limits. Changes to frozen assets or independent expectations require explicit finite authorization.

Shared parser, interpreter, conjoinment, source-fragment, communication-operand and native Void provenance regressions remain. Shared low-level interpreter cases retain Rust and generic systemless settings.

CaseComposed obligation
groupingI/GE preserves the nested 2 * (1 + 2) expression and result binding.
statementsThree ordered native statement children declare explicit let mut, assign an increment, and print.
fieldsNative record declaration plus Y-composed construction preserves both fields and member use.
calculationsBoth Op records retain their order, grouping, prefixes, postfixes, and combined calculation.
communicationCE composes bounded Tokio send and receive expressions; native E scaffolding creates the runtime and handles Result/Option.
conditionalsThe composed false/true/fallback chain retains ordered, distinct branch bodies.

Each <case>.aml.txt is a complete AML document defining the application lucid_nested_rust with source location /src/main.rs. It uses an ordinary composed FW entry point with explicit unit output. Native scaffolding never replaces the composed feature with EA. Communication supplies its native async block explicitly. The current CE path validates operands; Cargo checks the emitted async context. This case does not establish general compiler inference or validation of asynchronous execution contexts.

The public call is:

bundle, err := service.Evaluate(input, GenerationOptions{
IncludeRuntime: false,
})

The generation runner checks input immutability, one returned application, ordered file paths, dependency metadata, duplicate/unexpected paths, and exact bytes for all five artifacts:

/src/main.rs
/Cargo.toml
/src/config.rs
/start.sh
/stop.sh

Expected Rust sources and shared support artifacts are independently authored, checked-in oracles. Compare them using bytes.Equal; do not trim, format, reorder, normalize, regenerate from actual output, or replace actual files with expected ones. Common immutable support expectations are shared across case mappings.

Five complete pairs use the existing plain manifest and lock. future-composed checks CV construction, CO assignment, COB binding, DV native/composed operands, and ordered single evaluation. future-move returns an owned non-Copy future with a borrowed parameter lifetime; future-infer covers nested construction and inferred capture. future-borrow-escape requires E0373, while future-move-reuse requires E0382. The three positive generated programs also have a bounded execution check of their assertions.

lucid_future_test.go checks malformed compositions, source/resource isolation, and async-context boundaries. Existing complete pairs and their expected bytes are unchanged.

Six positive complete-AML/source pairs use the same application and five-file bundle shape:

CaseWitnesses
select-communicationDOC-composed ordered receives and send, non-Copy payload, absent/populated bodies.
select-bindingsCaller-named/raw DOC results, explicit outer O assignments, caller-supplied _, explicit disposal, singular/plural OC inputs and DOC with E.
select-default-orderExplicit OC defaults authored first/middle/last; stable ordinary branch order.
select-degenerateExplicit OC default-only and empty selections, empty bodies, subsequent statement and singular/plural OC unit values.
select-nesting-hygieneNested selection, preserved caller helper-like name, explicit repeated assignments, body once.
select-closed-receiveExplicit Option handling and scope across subsequent use.

Three more complete-AML/source pairs require successful exact generation and intentional Cargo rejection: select-sync-context (E0728), select-borrow-conflict (E0499), select-moved-send (E0382). The runner requires the intended code and a primary source/expansion span, rejects unrelated compiler errors, and never treats dependency/setup failures as an expected negative.

selection-invalid/ contains 35 complete AML documents for invalid CI/BI/OC/DOC compositions. They cover DO/DOB and bare guard rejection, Definition metadata and cardinality, placement and unsupported codas as well as existing CI/BI rules. Checks assert the classified underlying semantic cause separately from application/file context, no panic, unchanged input, and zero returned bundle. Selection isolation reuses complete fixtures for A/B/A, previous-bundle stability and equivalent explicit/embedded resources.

The positive projects use ordinary FW and native async scaffolding. CI/BI/CE and OC/DOC remain composed; ordinary O performs caller-authored outer assignments. Every BI needs a caller-supplied Definition, including defaults. Default metadata orders the branch and never supplies a wildcard or ready value. No compiler temporary or drop statement is inserted. The original communication fixture continues to use ordinary DOB outside BI, unchanged. See the selection contract for priority, defaults, result handling, cancellation and binding limits.

Rust uses the Void sentinel for absent named forwarded singular children and requires all supplied conjunction clauses to be true. Empty plural collections and explicit keyless records retain their distinct behavior.

Six positive applications cover unconditional X, Calculation-controlled X, the existing X/I adapter, OG/DOG conditional bindings, all four iterator binding shapes, caller-supplied iterator adapters, explicit borrowed matching, async receive conditions and direct PO labels. Nested labels exercise targeted break/continue. Ordered bodies retain their scope and appear exactly once. Native statements establish setup and async context; X, conditional Definition and label composition remain in the logemes under test.

CaseWitnesses or intended native diagnostic
iteration-conditionsUnconditional repetition, direct Calculation and retained ordered I/Evaluation conditions.
iteration-bindingsOG singular/plural metadata, DOG composition, nested punctuation and caller-explicit borrowed patterns.
iteration-asyncDOG with an explicit awaited receive and caller-supplied Tokio async context.
iteration-traversalWildcard, single, discarded-pair and named-pair bindings, with caller-supplied iterable expressions.
iteration-labelsPO directly labels unconditional, conditional, definitional and iterator loops.
iteration-nesting-scopeNested labels, targeted break/continue, body-local scope and exactly-once ordered body emission.
iteration-nonbooleanE0308: a non-Boolean Calculation used as a while condition.
iteration-binding-scopeE0425: a conditional binding used outside its loop body.
iteration-sync-awaitE0728: an awaited condition outside async.

The last three applications require exact generation followed by their intended native diagnostics. Native pattern/type/ownership rules remain Rust's responsibility; successful compilation does not prove runtime order, termination or channel behavior.

iteration-invalid/ contains 50 complete AML documents covering conflicting conditions, iterator/condition mixtures, three-part composition, body and child cardinality, ordinary Definitions used as conditions, OG/DOG metadata and placement, and PO child/label/coda rules. They use the same classified-cause, zero-bundle, immutability and no-panic requirements as the 35 selection-invalid cases. Iteration isolation covers A/B/A reuse, earlier bundles and explicit versus embedded resources without changing selection isolation obligations.

Eight stored primitive/iterate-*.rs.txt expectations render the actual Iterate Default case for Definition, Calculation, Evaluation and unconditional branches, plus wildcard, single, discarded-pair and named-pair traversal. These low-level checks supplement complete AML; they do not bypass composition validation as evidence of application support.

Iteration uses the plain and Tokio rt/sync manifests and retained locks. The iteration contract defines the four categories, OG/DOG fragments, direct PO child forwarding and rejection of initializer/condition/step composition.

Execute and Execution exclude Deferred inputs, forwarding and branches. Scheduling expressions require explicit caller-supplied futures and context.

schedule-direct exercises V's native Key and schedule-composed exercises MV's composed Instantiation without supplying Deferred. The four documents in scheduling-invalid/ cover Deferred True and False on both routes, asserting the unchanged Unsupported cause, zero bundle, input immutability and no panic. TestLucidDeferredRejected checks these failures, and TestLucidSchedulingIsolation checks reuse and selected resource providers. These tests do not expand the accepted execution child roles or certify other async forms. Caller-supplied futures and Tokio setup remain explicit.

Expected and Generated projects use the existing manifests and retained locks. These scheduling checks compile without executing applications or deployment scripts.

See the execution contract for the distinction between scheduling and resource cleanup through RAII. Removing the last unsupported markers does not establish complete Rust support or verified runtime behavior.

Follow the validation policy. Full local validation requires an explicit request; focused checks establish only their stated boundary. The development guide owns tool provisioning, environment and validation budgets.

For an authorized native-compilation check, run:

Terminal window
scripts/l-ci native

This records fresh evidence for Expected and Generated compilation of the current inventory, including intentional native negatives, and the native-metadata arrow regression. It compiles independently authored expected projects and actual returned projects without repair. A byte mismatch does not block compilation of materializable output; generation failure records a blocked phase. The arrow regression reuses the retained plain manifest and lock rather than adding a corpus fixture.

The configured native stage compiles only. The three future cases have a separate tagged execution check; when that check is requested, run it on macOS or Linux with the pinned toolchain and retained dependencies:

Terminal window
L_LUCID_ARTIFACT_DIR="$PWD/.harness/runs/lucid-futures-$(date -u +%Y%m%dT%H%M%SZ)" \
scripts/l-go test -mod=readonly -count=1 -tags=nativecompile \
-run '^TestLucidFutureExecution$' -timeout=30m -json ./logiceme

Retain each fixture's initial lockfile and frozen dependency resolution. Missing tooling, dependencies or expired deadlines are failures. Generated start/stop scripts remain artifacts. Compilation alone does not establish execution behavior.

For requested full repository validation, run scripts/l-check; it includes linting, unfiltered acceptance and the configured native-compilation stage. Report any separately requested future-execution results explicitly. Preserve assertions and budgets; do not substitute focused checks for the gate.

Five complete applications under this directory exercise Declaration adapters.

CaseRouting and forwarding obligation
declaration-operationKA forwards one named FW with two ordered statements and deduplicated nested imports.
declaration-descriptionHA forwards bare U's helper and main functions once, in order; main calls helper natively.
declaration-evaluationFOB receives GA's composed I/GE grouped multiplication; the result is subsequently used.
declaration-instantiationFOB receives MA's Y construction with fields 11 and 22; both fields are read.
declaration-iterationPA forwards X/I/W's conditional loop, ordered body and following statement between native function-boundary fragments.

The vowel selectors use consonant action names; Declare's nominal selectors and singular children are unchanged. Rust FW signatures remain parameterless with explicit unit results, Y has two fields, and PA does not introduce a new W child role. These choices isolate adapter routing from unrelated integration limits. No EA, native replacement loop, dispatcher alias, or compiler repair is involved.

Rust expectations are authored from literal template spans and compared without normalization. The applications are not executed. The ledger records generation, compilation and acceptance evidence.

The invocation contract prepares canonical absence for omitted KY Receiver and distinguishes prepared native Void from the bare absence sentinel. A supplied Receiver retains its original bytes. Explicitly empty or whitespace-only Receiver is rejected as InvalidInput with the exact leaf cause Rust KY: Receiver must be nonempty when supplied. Quoted "Void" comparisons retain their textual meaning.

CaseInvocation obligation
invocation-namedA composed parameterless FW helper, receiverless KY with zero or supplied arguments, a qualified callable, an explicit receiver, and receiverless KY under MV with explicit Tokio scaffolding.
invocation-voidComposed KY calls with a native Key or Receiver spelled Void; native helper declarations isolate the invocation route from Func-field interpolation.

Both pairs use independently authored exact source expectations and the existing five-artifact bundle. invocation-named reuses the Tokio rt/sync manifest and retained lock; invocation-void reuses the plain manifest and lock.

invocation-invalid/ contains the two complete malformed Receiver documents. TestLucidInvocationInvalid checks their exact classified leaf causes, zero bundles, input immutability, no panic and selected Instantiate/Instantiation assets. TestLucidInvocationIsolation evaluates invocation-named, schedule-composed and invocation-named again using one service under filesystem and embedded providers, checking exact bundles and previous-result stability. Additional Rust interpreter tests compare bare/quoted equality and inequality without mutating metadata or parsed source. Preparation tests distinguish omitted Receiver from native Void, including inherited equal-byte metadata provenance.

Native helper declarations isolate KY from Func-field interpolation. These invocation witnesses do not establish BW, general signatures or KYC behavior.

The callable-name contract preserves native names spelled Void during exact Meta.Func.Key interpolation. The helper uses interpolation's existing Func decoder, keeping the decoded record authoritative over a differing root Meta.Key. Output types and indexed Funcs have separate provenance contracts below.

CaseCallable-name obligation
function-void-flatDeclare Void through composed FW with flat Key, empty Inputs and unit Outputs; retain W/BOD/E body and a composed KY call through MOB.
function-void-recordDeclare the same function through FW with the explicit framed Func record; retain the same composed body and invocation.

The two independently authored source expectations reuse the existing plain manifest, support expectations and lockfile. Every returned artifact remains an exact comparison.

TestLucidFuncKeyProvenance covers exact interpolation and bare/quoted equality and inequality under Rust, differing record/root names, ordinary names, empty and absent controls, and repeated interpretation without metadata, working-variable or parsed-source mutation. Empty Key compares unequal to bare Void, while the explicit prepared Func = Void sentinel compares equal. A completely unset Func entry retains its empty-record fallback; it also compares unequal and is not promoted to native-name provenance.

These callable-name witnesses do not establish general signatures or runtime behavior. Generated Rust applications and scripts remain unexecuted.

The callable contract defines typed FW functions, bounded BW placement and KY invocation. Omitted or empty Outputs omit the return annotation; native Rust checks supplied types.

CaseComposed obligation
callable-typed-flatOne/multiple typed FW inputs with flat metadata, explicit output and KY calls.
callable-typed-recordExplicit Func, tuple/raw-identifier parameters in order, native name Void and nested import propagation.
callable-outputsNamed FW omitted, empty, unit and nonunit Outputs; absent annotations mean unit.
closure-inlineKY/BW through flat and explicit Func records; zero/multiple typed inputs and inferred/explicit output.
closure-stored-captureKOB binding, KO assignment into caller-declared uninitialized local, named KY calls, borrowed String capture and owner reuse.
callable-unit-mismatchExact generation followed by E0308 for returning an integer from a named function without Outputs.

These independently authored source expectations follow literal template spans and use the plain manifest/support/lock variant. The explicit BW Func records omit Key, which decodes as an empty name; the preserved record parser does not accept the literal empty-field spelling Key: ,.

callable-invalid/ contains 62 complete AML cases. Fifty-one cover required names, bounded BW placement, KY children/metadata, Func/flat exclusivity, unsupported Capture/headers, strict nested fields and framing errors; eleven cover MY signatures as described below. Tests assert exact classified leaf causes, zero bundles, no panic and input immutability. Interpreter controls retain existing Prop rendering and repeated-interpretation state. A/B/A checks use filesystem and embedded providers with import isolation and Operate/Operation/Instantiate/Instantiation resource provenance.

All native checks compile only; closure invocation, capture behavior and owner reuse are not executed. No Rust runtime parity is claimed.

callable-output-void supplies the nonunit alias type Void = u8; as the explicit return type of composed FW functions and BW closures, each using flat metadata and an explicit Func record. All four callables are invoked through KY and their results have typed uses. The independently authored source retains the frozen -> (Void) punctuation. It uses the plain manifest, shared support expectations and retained lock.

TestLucidFuncOutputProvenance checks joined and parenthesized output interpolation, bare/quoted comparisons and raw-list presence under Rust. Missing/empty Func and Outputs, unit/ordinary/multiple outputs, and repeated interpretation without state mutation remain explicit controls. Only exact Meta.Func.Outputs~ gains Rust native-source provenance for a nonempty output collection. Indexed Funcs have the separate MY contract below.

Generated Rust applications and deployment scripts remain unexecuted. The ledger records generation, compilation and acceptance evidence.

The MY contract defines required receiverless signatures with optional return annotations.

trait-signature-outputs composes MY from eight ordered Func records: missing and empty Outputs, explicit unit/scalar/multiple/tuple outputs, nested-comma parameter types and a native method/output type named Void. An inline native type alias and composed A/FW/W main provide the application scaffold. The trait declarations are not native scaffolding. The independent source expectation follows the template and uses the plain manifest and retained lock.

Focused indexed Funcs tests exercise numeric and Count/Add access, exact names and joined output text, raw-list presence, bare/quoted Void comparisons, nested parameters, bounds and repeated interpretation without mutation. The direct Rust decoder returns no partial records on malformed input; complete AML rejects malformed records before rendering with classified causes.

Eleven of the 62 callable validation cases cover supplied/empty Receiver, missing method names, unknown/duplicate/malformed Func fields and invalid input Props. Filesystem/embedded A/B/A checks compare complete bundles and verify input, prior-bundle and resource isolation.

These witnesses cover receiverless required signatures. Empty traits and local generic/lifetime parameters have separate controls below. Composed methods, per-method parameters and implementations remain outside this contract. Generated Rust applications and deployment scripts are not executed.

The empty-composition contract defines braced Y/HY/MY output for empty effective collections.

empty-instantiations covers omitted and explicit empty Props/Funcs, braced HY records and Y constructions through MOB, empty MY traits, a populated HY/Y control, typed uses and trait references. The feature under test is composed; native fragments supply ordinary uses rather than replacement declarations. The independent source expectation reuses the existing plain manifest and lock.

Six exact primitive cases cover the empty and nonempty routes. Twenty-one preparation cases cover canonical missing collections, explicit empty lists, inherited/local precedence and malformed local/inherited records. Repeated preparation compares effective metadata by key/value/type; original inputs, resource data, parsed tags and source bytes remain exact and immutable.

Five stored malformed inputs in empty-instantiation-invalid reject empty native collections with unrendered headers/methods, and empty HY with Shape Sum. They assert classified leaf causes, zero bundles, no mutation and no panic. A/B/A service reuse under filesystem and embedded resources verifies exact bundles and selected Instantiate/Instantiation provenance.

Empty declaration support does not implement composed members, composed generic-header children or sum types. Local String parameters have separate controls below. Generated Rust applications and scripts remain unexecuted.

The keyed GI contract requires every supplied pattern/body pair and only explicit terminal fallbacks.

Three complete applications use the exact-bundle/native runner:

CaseObligation
keyed-conditionalsSingle and multiple arms, preserved final bindings, exhaustive Boolean arms, literal/tuple/constructor/range patterns, direct/composed terminal fallback, fallback-only, caller wildcard, quoted/qualified/parenthesized Void, nested bodies and separately grouped category ordering.
keyed-nonexhaustiveTwo supplied integer patterns remain intact; Expected and Generated projects produce E0004 rather than acquiring a fabricated wildcard.
keyed-call-patternA native call-shaped pattern remains intact and produces E0164; no synthesized equality guard.

Fourteen stored keyed-invalid documents cover cardinality, empty Key/patterns, unexpected children and direct/composed duplicate or nonterminal fallbacks. They assert exact classified leaf causes, zero bundles, immutable input and no panic. Five exact Evaluate primitive cases and thirteen preparation cases cover one-shell rendering, repeated interpretation, Count restoration, inherited/local Key precedence and native Void provenance. Filesystem/embedded A/B/A reuses keyed-conditionals, existing conditionals, then keyed-conditionals, checking all artifacts, prior bundles and Evaluate/Evaluation resource provenance.

The independent oracles use the plain manifest/lock and exact byte comparisons. Runtime branch selection is not executed or claimed.

The local-input contract defines glyph-local Lifetimes and GenericTypes String inputs on FW/HY/MY declarations and Y/named KY applications, with explicit forwarding and no additional records or child categories.

CaseComposed obligation
generics-functionsFlat and record FW; lifetime-only, type-only and combined parameters; inline bounds; nested BW using its surrounding type without receiving a suffix; nongeneric neighbors.
generics-recordsBorrowed single/multiple-field HY; Y with explicit arguments and inference; typed uses and later owner reuse.
generics-traitsEmpty and populated MY; trait parameters emitted once and referenced by receiverless signatures; nongeneric neighbor.
generics-callsNamed and receiver KY; explicit early-bound lifetime; final-path-component arguments; nested comma/function-pointer native list contents; supplied type Void and nongeneric neighbors.
generics-late-bound-lifetimeExplicit call-site lifetime remains supplied and produces E0794.
generics-unused-parametersEmpty generic HY/Y retain their requested syntax and produce E0392, without hidden fields.
generics-argument-arityExcess caller-supplied type arguments remain intact and produce E0107.

All seven independent source oracles follow intended composition and literal template layout. The Expected stage compiles those projects before Generated output is considered. Each uses the existing plain manifest, support expectations and retained lock. Tests compare all five returned artifacts byte-for-byte; no output normalization or oracle-update mode is provided.

Twenty complete AML inputs in generics-invalid/ cover blank values, unsupported forms, anonymous calls, inputs incorrectly placed inside Func records, duplicates and inherited Class/Object metadata. An inherited-input EA case exercises the file-boundary guard. Assertions require the classified leaf cause, zero-value bundle, unchanged input and no panic.

Fifty exact primitive profiles cover all ten suffix sites with absent inputs, lifetime-only, type-only, both inputs and native type Void. Additional preparation and lookup controls cover canonical absence, local provenance, blanks on every supported form, inherited sentinel/blank/override rejection, repeated immutable interpretation and generic systemless lookup. Filesystem/embedded service reuse checks A/B/A output, earlier bundles and provenance for all four selected assets.

Consult the dated ledger for observed gate outcomes. Generated Rust applications and deployment scripts remain unexecuted; compilation establishes neither runtime behavior nor ownership-inference parity.

See the input contract for native String framing, glyph-local scope and declaration/application placement. Trait-level inputs do not add method-specific lists; dedicated const-generic, independent where-clause and generic implementation interfaces remain separate work.

FAILURES.md records the latest dated evidence. Record generation errors/panics, every actual bundle, expected references, byte-difference evidence, expected/actual Cargo results, and blocked phases. Classify causes as production generation/validation, support assembly, fixture/harness, infrastructure, or a reviewed expectation-only mismatch. Compilation success alone cannot justify expectation-only: review literal contents, operation order, scopes, and all support artifacts first.

The ledger records whether the current generation and native obligations passed at a given revision. A documentation update alone establishes no new behavioral result. For subsequent behavior changes, use an existing exposing regression when available and repair the responsible production layer within the approved scope. Keep independent expectations and frozen hashes; changing either requires a concrete, separately scoped amendment, never an automatic update from actual output. Consult the current integration limits before treating the current corpus as support for additional compositions.