Skip to content

Rust target contract

The eighteen frozen Rust segments support selection, iteration, callable signatures, empty records/traits, keyed matching and local lifetime/generic lists through bounded Rust compiler preparation. L, Lyger and Logiceme are implemented in Go; generated Apps and orchestrators use Rust. Raw Evaluate calls return Rust source bundles with optional runtime support.

The templates retain Meta, Funcs, Props, Ops and the existing Conjoinments categories. Qualified cases can supply fragments completed by their parent. OC/DOC supplies selection assignments; OG/DOG supplies conditional bindings; PO defines a label directly on its Iteration. Lifetimes and GenericTypes are an approved Rust-specific interface on the existing named declaration/application cases. The contracts below define their bounded integration; retained compiler entries and unused template routes do not establish additional support.

templates.sha256.json freezes the current asset bytes. The Lucid suite guide owns the current case inventory and validation commands. Its future cases also execute generated programs; the dated ledger records results for its stated revision. The frontend/runtime record tracks process supervision. Deployment scripts remain unexecuted.

Calculation, Description and Iteration retain their frozen composition wrappers. Declaration renders the file header; Evaluation forwards BI's Definitions, Operations and Default; Definition forwards PO's Iteration directly; Execution excludes Deferred. Operation and Instantiation explicitly forward the two local generic/lifetime inputs through their approved cases. The Declaration composition witnesses exercise the outer action selectors and singular child forwarding. Frozen assets and independent expectations require explicit authorization for changes.

The core supplies the small implicit vocabulary: Process, Function, its Invoke and Return members, construction descriptors, Retain, Start and Execute. Start composes Build then Run; Execute composes Start then Await. Both retain their any App signatures.

The privately imported Storage dictionary composes storage, copying, checking and capture operations from source Functions and small native leaves. Selected definitions carry their declaration dependencies; there is no unconditional helper aggregate. Storage's names do not become global builtin words. Source Functions supply their own invocation words, use normal local declarations and Return, and retain canonical declaration ownership.

IO.Print composes the operand's selected Render member with Write. Text retains exact bytes; Number uses the same source formatter as the runtime. Write holds stdout's lock, writes the value and one LF, and reports write failure through the App's native failure boundary. Its leaves perform individual host operations; no native formatting dispatcher or duplicated formatter remains.

Native source Function signatures use existing Func/Props metadata. The frontend Type slot binds a native type atom or selected source type declaration; Atoms binds ordered scalar/reference arguments. Label declares a result identifier; nested constructions bind that result once before their consumer. Assignment targets remain references. These frontend roles add no AML fields or logeme interfaces. Native and ordinary Function bodies share instruction lowering.

Runtime policy is authored in L source. Run scripts/l-go run ./tools/composition after changing its dependencies, then scripts/l-go run ./tools/composition --check to verify the derived AML, fingerprints and selection index. The CLI contract defines runtime selection and provider behavior. Logiceme consumes complete AML, not L source or private frontend plans.

operations/rust/process-*.def supplies Build, Run, Stop, Await and finish-continuation compositions to Lyger's private implementation catalog. These definitions use the existing logemes and native runtime calls. The frontend selects by semantic operation and canonical App target, then binds compiler-typed receiver, invocation and continuation values. These slots are internal compiler inputs; they add no public definition argument kind, Func field, segment interface or keyword overload. Each compilation loads and validates the complete catalog from its selected resource filesystem.

Main and Basic remain source-defined construction descriptors. Only Apps accept native process operations and implicit process Output/Error. Standalone Service declarations create no package; standalone body effects reject. App construction retains its primary Service and additional Service libraries. Start/Execute remain App-specific source compositions. This adds no in-process Service task, Class lifecycle, runtime argument transport or segment template.

Each application case passes complete AML to LogicemeService.Evaluate with IncludeRuntime: false, comparing src/main.rs, Cargo.toml, src/config.rs, start.sh and stop.sh exactly. The maintained corpus covers the core compositions below, selection, iteration, scheduling, Declaration adapters, invocation, typed and anonymous callables, source provenance, MY signatures, empty records/traits, keyed GI and generics. The suite guide owns the numerical inventory and intended native diagnostics; the ledger records generation, compilation and acceptance results separately.

The six core scenarios have distinct obligations:

Table: scroll horizontally to read all columns.

CaseVerified compositionBoundary of the evidence
groupingI/GE retains 2 * (1 + 2) through GOB bindingExpression grouping within the declared form
statementsThree BOD/E statements remain ordered within W/FWlet mut is explicit native text, not mutability metadata
fieldsDA/E declaration plus Y/MOB two-field constructionNative record declaration does not test HY's struct shell
calculationsDE/DOB retains both Ops, grouping, prefixes and postfixesSupplied operand syntax remains native data
communicationCE/DOB send and receive expressions preserve their order and bindingsNative fragments create Tokio, the async block and channel; Result/Option handling is explicit; no V/MV task or CI/BI selection is tested
conditionalsGI/BOG retains false, true and fallback branchesUnkeyed conditional chain, not general pattern matching

All six use named FW with empty parameters and explicit unit output. The empty Header loop, restored existing Func/Props/Ops records, singular/plural forwarding and ordered child categories are part of their compiler integration.

The five additional Declaration witnesses exercise KA forwarding a named FW, HA forwarding U's ordered functions, GA forwarding composed I/GE grouping through FOB, MA forwarding two-field Y construction through FOB, and PA forwarding X/I/W iteration within explicit native function scaffolding. Their outer vowel selectors use the action names Operate, Describe, Evaluate, Instantiate and Iterate; the Declare primitive still uses the category nouns Operation, Description, Evaluation, Instantiation and Iteration. Each forwards exactly one child. This does not establish support for every possible child form, signature or execution context.

Vowel / categoryConsonant / primitive
A / DeclarationB / Declare
E / CalculationD / Calculate
I / EvaluationG / Evaluate
O / DefinitionF / Define
U / DescriptionH / Describe
W / OperationK / Operate
X / IterationP / Iterate
Y / InstantiationM / Instantiate
V / ExecutionC / Execute

This table inventories template routes, not proven end-to-end Rust support. Singular and plural child categories retain their established meanings. No arbitrary letter combinations or codas are implied by a row.

FormsCopied responsibility / inputs and children
AFile header: package metadata and the Headers import loop.
EAExisting complete-file Contents route. It remains a standalone literal file through the existing assembler, not an inline composition workaround.
BADeclare Keys with Type, without an explicit value.
DA, KA, HA, GA, MA, PAForward one Calculation, Operation, Description, Evaluation, Instantiation, or Iteration through Declare, respectively.
EEmit Meta.Statement.
DECalculate from Meta.Ops; retain the existing Op.Type == "Calculate" grouping condition.
GEForward Calculations and Key to Evaluate.
CECalculate communication from the existing Op operand model: one operand receives, two send.
IForward Calculations and Key to Evaluate; retain its existing grouping selector.
GIUnkeyed Boolean selection; with Key, ordered native pattern/body pairs and an optional explicit terminal Void fallback.
CIForward ordered BI Evaluations to biased Tokio selection; preparation places the sole explicit default last.
BIForward one OC/DOC Definition, zero/one W Operation and Default to one selection alternative. Default controls ordering only.
O, OBDefine from native Values, with ordinary assignment or declaration-assignment.
OCDefine Keys = async { Values } from exactly one caller-supplied name/wildcard and one explicit nonempty native value, without children; a BI-only fragment.
OGDefine let pattern = value from one Key/Keys pattern and one nonempty explicit Value/Values expression, without children; an X-only condition fragment.
FO, FOBDefine from a singular Declaration child.
KO, KOBDefine from a singular Operation child.
DO, DOBDefine from a singular Calculation child.
DOCDefine Keys = async { Calculation } from exactly one caller-supplied name/wildcard and one Calculation, without native Values; a BI-only fragment.
DOGDefine let pattern = Calculation from one Key/Keys pattern and one Calculation, without native Values; an X-only condition fragment.
GO, GOBDefine from a singular Evaluation child.
MO, MOBDefine from a singular Instantiation child.
PODefine one caller-supplied label directly on one Iteration child, without native Values, an extra block or a semicolon.
BORoute to Declare with Keys and Type; no explicit initializer.
BOD, BOK, BOH, BOG, BOM, BOP, BOCExpose a singular Calculation, Operation, Description, Evaluation, Instantiation, Iteration, or Execution through Declare, respectively.
UDescribe ordered Operations.
MUDescribe updates using the existing Props loop.
WEmit ordered Definitions.
BWAnonymous callable syntax using Func and ordered Operations.
FWNamed function syntax using Func and ordered Operations; local Lifetimes/GenericTypes declare parameters.
XIterator traversal, unconditional repetition, Calculation-controlled repetition, or OG/DOG-controlled repetition; one Operation body. I remains a Boolean condition carrier.
YConstruct a named value from Props; an empty collection emits Key {}. Local Lifetimes/GenericTypes supply constructor arguments.
KYInvoke a named callable, an optional Receiver member, or a singular anonymous Operation, using Inputs. Only named calls accept local Lifetimes/GenericTypes arguments.
MYReceiverless required trait signatures from Funcs; an empty collection emits trait Key {}. Local Lifetimes/GenericTypes qualify the trait once. Omitted/empty method Outputs omit the return annotation.
HYStruct-shaped syntax from Props; an empty Record emits struct Key {}. Local Lifetimes/GenericTypes declare parameters.
VSchedule the invocation text in Key through tokio::spawn.
MVSchedule a singular Instantiation child through tokio::spawn.
CVConstruct an unscheduled future from one W body; local Capture selects Infer or Move.
DVAwait one native or composed future operand inside an asynchronous body.
CO / COBAssign / declare one binding from one CV or DV value.

The two local generic/lifetime inputs below qualify existing named declarations and applications without adding structural-parameter syllables or generic-path roles. CV/DV and CO/COB have the future contract below. Enum, general structural-pattern, mutability and implementation extensions remain outside these contracts; OC/DOC and OG/DOG do not establish those interfaces.

Optional Rust-only Lifetimes and GenericTypes String inputs contain native comma-separated list interiors without enclosing angle brackets:

Lifetimes: ~'a, 'b~
GenericTypes: ~T, U: Clone + 'a~

Table: scroll horizontally to read all columns.

FormsMeaningExample
FWDeclare function parameters, beside flat metadata or an existing Func recordfn borrow<'a, T>(...)
HYDeclare record parametersstruct Borrowed<'a, T> { ... }
MYDeclare trait parameters once, outside its Funcs signaturestrait Reader<'a, T> { ... }
YApply constructor argumentsBorrowed::<'_, u8> { ... }
Named KYApply arguments to the final named function/member componentborrow::<u8>(...), receiver.method::<T>(...)

The conditional suffixes emit nothing when both inputs are absent. If both are supplied, Lifetimes precedes GenericTypes with one template-owned , between the inputs. Callers own separators within each input. Supplied text is preserved without generic-list parsing, additional unframing, whitespace normalization or name extraction. Empty or whitespace-only supplied values receive InvalidInput. Native GenericTypes: ~Void~ remains a supplied type rather than absence.

These inputs are glyph-local. Effective inherited Class/Object/file metadata is rejected, including blank or sentinel-valued entries and files using standalone EA; a local override does not rescue inherited placement. Parent parameters may appear in child native types, but no parameter list propagates into child calls or neighboring declarations. Func/Prop/Op records remain unchanged; these inputs are not record fields. FW/MY reject these names inside Func records. BW, anonymous KY and other forms do not accept these inputs. Named KY requires a locally supplied Key.

Arguments attach to KY's final named component: Key Vec::new plus GenericTypes u8 spells Vec::new::<u8>(), not Vec::<u8>::new(). Callers can supply the latter complete native path as Key without new metadata. Trait-level parameters may be referenced by existing MY method input/output types; they are not repeated after method names and do not define per-method parameter lists.

Rust checks native syntax, argument arity, bounds, ownership and lifetime rules. Declaring a lifetime does not imply that callers may explicitly supply it: the native suite retains E0794 for a late-bound function lifetime. Empty generic structs retain their declared fields exactly and may receive E0392 for unused parameters; the compiler inserts no PhantomData. E0107 verifies that excess call arguments are not removed. No lifetime inference, cloning, borrowing, 'static, capture policy, argument inference or implicit default is introduced.

The four assets use conditional suffixes, explicit forwarding and Inputs declarations. Preparation installs canonical absence and native-source provenance; a Rust-only direct-primitive lookup fallback handles missing values for these two names alone. Generic systemless lookup and shared ordered rendering remain unchanged. Dedicated const-generic, independent where, generic implementation and per-method interfaces remain separate work.

The seven complete witnesses and focused controls are listed in the suite guide. Consult the ledger for observed generation, compilation and acceptance results. Native builds do not execute these applications or establish runtime or ownership-inference parity.

  • Declare uses typed let syntax. It adds no initializer, automatic mut, Default::default(), or clone. Declaration-assignment uses let ... = ...; ordinary assignment remains ... = .... Statement definitions, declarations, and MU updates have semicolons; OC/DOC and OG/DOG fragments do not. PO supplies the label colon and its Iteration child without another body boundary. W's copied Definition loop is unchanged.
  • Functions and anonymous callables use Rust fn/closure punctuation with the original Func interpolation slots. The templates add no implementation wrapper, signature preparation, move, or async qualification. The compiler restores existing Func records; Rust's Func.Inputs~ formatter supplies name: type parameters. Omitted/empty Outputs omit the whole return annotation; explicit Outputs retain their existing punctuation. FW keeps its opaque Receiver interpolation inside the parameter list, without adding conditions to format separators or receiver arity.
  • Interface and record shells use trait and struct. Fields use colons and commas; method signatures use Rust punctuation. StructTags text is retained as a comment rather than interpreted as Rust attributes.
  • Calls and named-field construction retain their existing child composition. If chains remain if chains. Keyed switches use match punctuation, with no generated selector binding, comparison guard, or ownership decision.
  • Conditional and infinite loops use while and loop. Range branches use for ... in ...; no iterator adapter, enumeration, borrowing, or channel-drain implementation is inserted.
  • CE's receive/send leaves use .recv().await and .send(...).await. They do not unwrap, bind, or otherwise interpret Option/Result, or check async context.
  • V/MV use tokio::spawn(invocation), without generating an async wrapper. The supplied invocation must already return a suitable future.
  • A preserves package metadata as a comment and uses the existing Headers loop for use statements. It prepares no safety attributes, modules, or imports.

Interpolation values remain opaque. The templates do not repair incorrectly formatted parameters, receiver/result lists, type spellings, quoted imports, operators, multiple-key bindings, or loop inputs. Unsupported tuple bindings and non-pattern match cases may produce invalid or incomplete Rust. Optional result slots and empty structure collections have the bounded contracts documented below. Raw multi-line StructTags text is not normalized into a safe multi-line comment. These are documented draft limitations, not promises of implicit conversion or validation.

KY's named-call route consumes its supplied Key and Inputs. Omitting Receiver prepares the ordinary absence sentinel and selects Key(Inputs). A supplied Receiver retains its exact bytes and selects Receiver.Key(Inputs); explicitly empty or whitespace-only Receiver is rejected with InvalidInput:

Rust KY: Receiver must be nonempty when supplied

Rust distinguishes native identifiers spelled Void from the absent-value sentinel. Rust prepared SourceString values do not equal an unquoted Void in template conditions; quoted "Void" comparisons remain textual. Absent Receiver replaces inherited local provenance even when its bytes already equal Void, without mutating file-owned metadata.

The invocation witnesses cover two bounded routes. invocation-named composes a parameterless helper call, qualified calls with supplied arguments, an explicit receiver and a receiverless KY under MV. invocation-void composes calls whose Key or Receiver is named Void, with native helper declarations isolating invocation from signature generation. Both retain the existing five-artifact bundle and reuse the plain or Tokio rt/sync manifest/lock variant. Consult the ledger for generation, native compilation and acceptance results; neither case executes the generated application.

These invocation witnesses do not establish BW, general signatures or KYC semantics. Native helper declarations isolate invocation-void from FW/Func-field interpolation; callable-name coverage follows below.

Exact Meta.Func.Key interpolation preserves a nonempty native name, including Void. The Rust provenance helper uses the same Func decoder as interpolation; the Func record remains authoritative when root Meta.Key differs. Bare Void compares unequal to a supplied native name, while quoted "Void" remains an ordinary textual comparison.

Output provenance has a separate contract. Empty Key and empty Inputs/Outputs retain their existing behavior, as does absent Receiver. An explicitly prepared Func = Void sentinel compares equal to bare Void; an unset Func dictionary entry falls back to an empty Func whose Key compares unequal. Neither absence representation gains native-name provenance.

function-void-flat declares Void through FW's flat callable metadata; function-void-record uses an explicit Func record. Both provide empty parameters and unit output, retain a composed W/BOD/E body, and call the declared function through KY. They reuse the plain manifest, support expectations and lockfile. These witnesses cover callable names without establishing other Func fields, indexed Funcs fields, general signatures or runtime behavior. See the ledger for the separate exact-generation, native-compilation and acceptance results.

Func/Prop records supply callable signatures. FW requires a nonempty name. BW creates a synchronous anonymous closure and is allowed only as KY's direct callable child or KO/KOB's direct value child within an enclosing callable. Named KY accepts no callable child; unnamed KY requires exactly one BW and excludes Receiver. KO/KOB retain ordinary assignment/binding punctuation.

Both FW and BW require a name and type for each input Prop. Only Key/Type are accepted there; supplied Value, StructTags and unknown fields are rejected. Flat and explicit Func signature metadata are exclusive. Func records accept only Key/Inputs/Outputs/Receiver, and unknown Receiver-Prop fields cannot silently become an empty receiver. BW excludes flat Key/Receiver and rejects a nonempty decoded record name or receiver. A Func record may omit Key, decoding to an empty name; the existing parser still rejects the literal empty-field spelling Key: ,.

Omitted or empty Outputs omit the whole annotation: named functions return unit, while closures use Rust output inference. Explicit output punctuation, including unit parentheses, is unchanged. Closure parameter types are still required. Native Rust infers captures; no move, clone or capture policy is synthesized. Supplied Capture and generic BA/U header children are rejected on FW/BW because the current templates do not consume those interfaces. Other advanced callable forms retain their existing paths without new support claims.

Five positive witnesses cover flat/record typed signatures, optional outputs, inline BW calls, stored BW through KO/KOB and borrowed capture with owner reuse. callable-unit-mismatch deliberately returns an integer from a named function with no Outputs and must produce E0308. All six use complete AML and compare all five returned artifacts. Native compilation, not execution, verifies these witnesses. Receiver methods, FWC/KYC and general ownership analysis remain outside this contract. The supported output and indexed provenance fields are specified below.

Future construction, awaiting, and value bindings

Section titled “Future construction, awaiting, and value bindings”

CV constructs an unscheduled future from exactly one W body. Its optional, glyph-local Capture is Infer (the default) or Move; these select Rust's inferred capture or ownership transfer. Neither form clones captures or starts a task. The body's final expression supplies the future's result.

DV awaits one future within a CV body. Supply either a nonempty native Key or one E, KY, CV, or DV operand, never both. The operand is evaluated once. Rust checks its Future implementation and result type. Awaiting does not unwrap errors, select a result representation, or imply process supervision.

CO assigns, and COB declares and initializes, one simple Key (or one-element Keys) from exactly one CV or DV child. Raw identifiers and _ are accepted. Type, mutability, native Value fields, and scheduling statements are excluded. For mutation, declare the storage explicitly before assigning through CO.

FW, HY, and KY retain definition, structural-data, and invocation ownership. Existing glyph-local Lifetimes/GenericTypes express signature relationships; CV does not infer 'static or introduce lifetime metadata. Nested synchronous callables reset the await context. Existing V/MV scheduling and OC/DOC selection forms retain their separate contracts.

The complete future-* AML/Rust pairs cover composed invocation and native operands, single evaluation, inferred and owned captures, borrowed signatures, and Rust rejection of escaping borrows and moved-value reuse. They add no L syntax or Function implementation.

Exact Meta.Func.Outputs~ interpolation preserves supplied Rust type text, including a sole type named Void. The existing provenance helper reads the same decoded Func as interpolation and recognizes only nonempty Outputs. The frozen FW/BW punctuation therefore remains -> (Void). Missing and empty outputs and the explicit Func absence sentinel retain their existing behavior. Bare Void remains an absence comparison; quoted "Void" compares text.

The complete callable-output-void application declares type Void = u8; and composes both FW functions and BW closures with flat and explicit Func metadata. Composed calls and typed result uses verify all four routes. It reuses the plain manifest, support files and lock. Indexed Funcs provenance has the separate MY contract below; see the ledger for compilation and acceptance evidence. This Lucid witness remains compile-only.

MY renders ordered receiverless signatures from its existing Funcs records. Omitted and explicitly empty Outputs emit no annotation; unit, scalar and multiple supplied outputs keep the parenthesized punctuation and terminating semicolon.

Rust decodes each Func through the existing balanced record machinery and uses the current name: type parameter formatter. Nested commas in tuples, generics and function-pointer types retain their source meaning. Exact indexed Key and Outputs~ fields preserve nonempty native names/types, including Void, using the selected record and current Count/Add binding. Other field provenance remains unchanged.

MY validates named signatures and named/typed input Props, rejects malformed or unsupported record fields, and rejects any supplied Receiver field, even empty. Its frozen template does not consume Receiver. Empty trait emission has the bounded contract below. Trait-level generic/lifetime inputs have the contract above; composed/default methods, independent method parameters and implementations remain separate work. Retained preparation entries are not proof of those routes.

trait-signature-outputs composes eight required signatures and an ordinary main, with exact five-artifact comparison and Expected/Generated native compilation. Eleven malformed cases and explicit/embedded A/B/A checks cover validation and isolation. Native compilation checks declarations; generated applications remain unexecuted. See the ledger for results.

Y with empty Props emits Key {}, HY with empty Props emits struct Key {}, and MY with empty Funcs emits trait Key {}. Omitted collections have the same result. Record braces are preserved; HY does not substitute a unit-struct declaration. The existing nonempty loops, selectors, inputs and forwarding remain unchanged.

Rust preparation supplies canonical &[]& only when the effective collection is missing. It preserves inherited metadata and explicit local overrides, and uses the existing record readers to reject malformed data rather than treating it as empty. This is a Rust preparation contract; shared Lucid absence behavior is unchanged.

An empty HY/MY native collection cannot accompany composed children, including member and generic-header children: the frozen wrappers do not render those collections. Such input receives a classified rejection rather than losing its composition. Empty HY accepts absent Shape or Shape: Record; Shape: Sum is rejected rather than emitted as a struct. This does not implement composed fields/methods, composed generic-header children or sum types, nor certify their nonempty paths. The separate local String inputs above also apply to empty shells.

empty-instantiations composes the omitted/explicit-empty variants, MOB initializers, a populated HY/Y control, typed uses and references to both empty traits. Exact primitive and preparation checks cover brace preservation, nonempty bytes, repeated use, inherited/local precedence and malformed records. Five complete malformed inputs cover these guards; filesystem/embedded A/B/A checks retain input, earlier-bundle and resource isolation. Expected and actual projects compile without executing Rust applications or deployment scripts. See the ledger for dated results.

CI owns the tokio::select! shell. OC/DOC own the complete left = async { value } Definition, and BI supplies only => and the selected body. CE owns its awaited channel expression; an ordinary O owns any explicit assignment inside W. No public BI Key, extra metadata, record field or logical category is introduced.

CI accepts only BI children, at most one default, inside a callable. Every BI, including Default: True, requires exactly one OC/DOC Definition and zero/one W body. Bare Calculations and DO/DOB guards are rejected. OC/DOC are allowed only as direct BI children; they are not standalone statements or general future adapters. Native async scaffolding remains explicit; Cargo checks actual placement.

OC consumes exactly one Key/Keys entry and one explicit, nonempty Value/Values entry, without children. DOC consumes exactly one Key/Keys entry and exactly one Calculation, without Value/Values. DOC accepts an otherwise valid Calculation, including E, CE send and CE receive. The async block returns that supplied value; it does not automatically await a future returned by it. Both allow Imports and Tags. The caller must choose a simple/raw identifier or _; composite patterns, assignment places and Type/Mutable/Parameter/Capture qualifiers are rejected.

Source alternativeEmitted behavior
DOC name with CE receivename = async { CE }; the selected body receives the explicit Option result.
DOC _ with CE send/receive_ = async { CE }; the caller explicitly discards the returned result.
DOC name with another Calculationname = async { Calculation }; the supplied expression remains the tail.
OC with Value ()name_or_wildcard = async { () }; an explicitly supplied ready alternative.
Default TruePlace the supplied Definition last, preserving other branch order; invent no name, value or readiness.
Empty CIExisting I/E composition emits { ::core::future::pending::<()>().await }.

A named selection pattern creates a branch-local binding. To update an outer variable, the caller supplies the branch name and an ordinary O inside W, such as selected = async { receiver.recv().await } => { existing = selected; }. The compiler does not derive a BI Key or introduce temporary bindings, assignments, drop calls, cloning, moving or unwrapping. _ follows Rust/Tokio wildcard behavior; callers needing explicit disposal before later statements supply a named result and their own drop statement. Destructor timing has no runtime verification. Ordinary O/OB/DO/DOB statement punctuation remains unchanged.

biased; gives earlier ready branches priority and can starve later branches. With a caller-supplied ready final alternative, fallback occurs when preceding futures report Pending during polling; this is not an atomic readiness test or Tokio's all-disabled else. Default: True alone gives no readiness guarantee. Selection runs on the current task. Async-block operands execute when polled, without promising eager evaluation of every operand. See Tokio selection.

Closed receive results remain None for explicit handling. Cancelled receives do not consume a message; a cancelled send can drop its unsent payload. The caller chooses whether to bind or discard the send Result. Reservation/permit-based lossless sending is outside this contract; see Tokio send cancellation. Verification of these selection witnesses remains generation/compilation only; the ledger records observed results.

Iterate owns repetition syntax and the body boundary. Every X has exactly one Operation body and one of four abstract behaviors:

Table: scroll horizontally to read all columns.

BehaviorSupplied inputs/childrenEmitted shape
Iterator traversalIterable with the existing Key, Index and RangeArity metadata; no condition childfor pattern in iterable { body }
Unconditional repetitionNo Iterable or condition childloop { body }
Conditional repetitionOne Calculation, or one I/Evaluation adapter containing ordered Calculationswhile condition { body }
Definitional repetitionOne OG or DOG Definitionwhile let pattern = value { body }

The I route represents the same Boolean condition category; it is not a fifth loop mode. Conflicting condition categories, repeated conditions, iterator/condition mixtures and missing or extra bodies are rejected before rendering. An ordinary O/OB/DO/DOB is not a conditional Definition. Initializer/Evaluation/step composition is rejected. X provides no three-part lowering, hidden initializer, first-iteration flag or automatic post-step.

OG consumes exactly one nonempty Key/Keys pattern and one explicit, nonempty Value/Values expression with no children. DOG consumes exactly one nonempty Key/Keys pattern and one Calculation with no Value/Values metadata. Both are permitted only as X's direct conditional Definition. Define supplies let and = without a semicolon; callers supply the pattern, not an entire let expression. Nested tuple/record punctuation and caller-written binding modifiers remain native data. Framed pattern commas do not create extra Keys. Rust checks native pattern, type and ownership legality; the compiler checks composition and cardinality. No structural-pattern forms or pattern parser are introduced.

PO consumes one nonempty Key/Keys label and exactly one Iteration child, without Value/Values or a coda. It is a Definition statement in W within a callable. The caller supplies the native spelling, such as 'outer; Define supplies the colon and forwards Conjoinments.Iteration directly, never through Meta.Values:

'outer: loop {
continue 'outer;
}

There is no labeled wrapper block. Labels, nested break/continue targets and body scope are preserved without generating or renaming identifiers.

RangeArity 0 emits _, 1 emits Key, and 2 (also the existing absent-arity default) emits (Index, Key) or (_, Key) when Index is absent. The iterable must already yield the required items. Caller-supplied ranges, enumerate(), reversal, filtering and other library expressions need no extra loop category; the compiler adds no iterator adapter, borrowing or cloning. DOG can consume an explicitly awaited Calculation with caller-supplied async scaffolding. There is no inferred async mode, channel-draining primitive or async wrapper.

All ordinary O/OB/DO/DOB and OC/DOC contracts remain unchanged. The supplied template interpolation modifiers own layout; native multiline-literal formatting is not broadened. Complete-AML and primitive fixtures cover the approved branches, with intended native diagnostic cases for a non-Boolean condition, an out-of-scope binding and awaiting outside async. They compile only: execution order, termination and Rust runtime parity are not established.

Execute/Execution have no Deferred input, forwarding or conditional branch. V schedules its supplied Key expression, and MV schedules its supplied Instantiation through tokio::spawn. These templates add no invocation, async wrapper, join, clone, ownership conversion or cleanup operation. The caller supplies a suitable future and execution context. Other execution-role and callable integration gaps remain separate follow-up work.

Supplying Deferred in Rust AML is still rejected before rendering with the existing Unsupported classification and diagnostic, including False:

Rust <form>: Deferred is unsupported; Rust has no deferred execution operation

Omitting Deferred is the supported interface; no scope-exit syllable or facility is defined. The 18 Rust segment assets contain no compile_error! marker. This is an asset inventory fact, not a claim that all template routes or compiler preparation branches are integrated.

Rust resource cleanup can use ownership and destructors (RAII), governed by Rust's drop scopes. The borrow checker checks ownership and borrowing constraints at compile time; it does not execute cleanup. Ordinary Drop::drop is synchronous. Callers own any explicit guards, cleanup requiring error handling, and asynchronous shutdown. Releasing a resource does not establish a successful flush, completed transaction or completed shutdown.

RAII does not imply deferred-call argument evaluation or function-exit ordering. The logemes synthesize no guard or Drop implementation. Explicit process supervision and shutdown remain dedicated support responsibilities; std::process::exit does not run stack destructors. Generated Rust Apps remain unexecuted by this suite, so neither destructor timing nor shutdown behavior is runtime-verified.

schedule-direct (V) and schedule-composed (MV), plus four Deferred rejection documents, cover scheduling. The composed witness uses KY's receiver-method form, ready.into_future(); the invocation witnesses separately cover receiverless KY. Consult the ledger for observed generation, compilation and acceptance results.

Evaluate's keyed GI branch emits one match shell and preserves all supplied Calculation patterns and Operation bodies in their category order, including a single arm and the final arm. Children need not alternate in AML. Every body requires an explicit pattern; at least one pair is required.

Key supplies the native subject. Effective inherited metadata and local overrides are honored, including native Void provenance; an empty or whitespace-only subject is invalid. Unkeyed GI remains the existing Boolean condition route. A bare identifier in a keyed arm follows Rust's binding rules, not an inferred equality comparison. Rust checks native pattern syntax, types, borrow/move rules and exhaustiveness. No equality guards, clones or structural pattern forms are generated.

A Calculation that compares equal to the existing standalone Void carrier after composition supplies the fallback. This includes GE^E{Statement: Void}. There may be one fallback, and it must be terminal. Missing patterns, empty pattern output, duplicate/nonterminal carriers and unexpected child categories are classified composition errors; no child is silently discarded. The compiler checks compiled children with the same indexed comparison used by the template without rewriting their source.

Quoted "Void", qualified names such as Choice::Void and parenthesized native patterns remain literal patterns. Use qualified spelling for a native constant whose bare name would collide with the fallback carrier. Caller-written _ remains ordinary Rust pattern syntax; the compiler does not analyze its coverage or invent a fallback from the final body's position.

keyed-conditionals compares exact single/multiple/nested matches, native patterns and direct/composed fallbacks. keyed-nonexhaustive requires E0004, proving a wildcard is not fabricated; keyed-call-pattern requires E0164, proving a call expression is not converted to an equality guard. These projects compile only; these witnesses and their deployment scripts remain unexecuted.

Rust iteration uses the existing Void sentinel for absent named forwarded singular children, and conjunctions require all supplied clauses to be true. Empty plural collections and explicit keyless records retain their behavior. The ledger records observed results for the maintained corpus.

A template case, a parser/validation entry, successful generation and a compiled application are separate levels of support. The remaining mismatches below are follow-up work; this reference does not authorize repairs or interface changes.

AreaCurrent state and limitation
Named invocation and callable namesKY's omitted Receiver/native scalar Void handling and exact Meta.Func.Key provenance have the bounded contracts above. Singular output and indexed MY Key/Outputs~ provenance are covered separately; other Func fields, general signatures and KYC semantics remain outside these contracts.
Typed and anonymous callablesFW/BW and named/anonymous KY have the bounded contract above. BW is restricted to KY or KO/KOB inside callable scope; inferred parameter types, function receiver methods and generic closure declarations remain unsupported. FW parameters have the separate local-input contract above.
DeferredAbsent from Execute/Execution inputs and forwarding; any supplied Deferred, including False, retains its existing compiler rejection. No deferred-execution operation is implemented.
SelectionCI/BI supports the bounded selection contract. No fairness, cancellation, destructor timing or Rust runtime behavior is established by compilation.
Three-part loopsUnsupported by X and rejected before rendering. Iterate has no three-part marker or compiler expansion.
Future compositionCV/DV construct and await futures; CO/COB bind their values under the bounded contract. FW remains synchronous and can return a future through its existing output signature. Function receivers, FWC/KYC and generic closures remain outside these contracts.
Output-field provenanceExact Meta.Func.Outputs~ preserves supplied native types, including Void, for flat/record FW and BW. Empty-output behavior is preserved. Indexed Funcs Key and Outputs~ have the bounded MY contract above; other indexed fields are not broadened.
MY trait signaturesReceiverless Funcs records and optional outputs are covered above. Empty traits have the bounded empty-composition contract; supplied Receiver metadata is rejected. Trait-level parameter lists use the local-input contract above. Composed methods, per-method parameters and implementations remain outside these contracts.
Generics, enums and patternsLocal String parameters/arguments are supported only on FW/HY/MY/Y/named KY as described above. Const-generic, where-clause, per-method and implementation interfaces remain separate work. OG/DOG do not establish general compositional patterns or enums.
Header/module/runtime coordinationA retains its package comment and Headers/use loop. The source assembler emits graph-owned safety/module declarations separately at the known A boundary, and runtime support wraps composed l_main. Configuration initializes before user effects. Explicit library-only targets omit executable support. Separate frontend/runtime regressions cover these boundaries.
Ownership and mutabilityThe frontend typed plan determines storage and required mutation from resolved L instructions, preserves paragraph activations and value snapshots, and rejects unassigned reads. It introduces no glyph fields, hidden L-value initialization or general native ownership/lifetime inference. The standalone Lucid mutation witnesses still supply native text explicitly.
Iteration and keyed GIX has the bounded four-category contract above. Keyed GI preserves native patterns and explicit fallback carriers as described above. Iterator adaptation and native pattern legality stay caller-owned/rustc-checked; these standalone branch/loop witnesses remain compile-only.

The compiler separates Inputs/Headers initialization from executable case selection, dispatches parsed primitive calls while preserving wrapper whitespace, prepares the existing metadata records and exposes only explicitly forwarded child aliases. These boundaries do not establish support for unrelated preparation paths.

Templates own whitespace and punctuation. The current source expectations were independently derived from their literal spans, including the explicit % and & interpolation modifiers, and compared without formatting or normalization.

The source assembler uses StructureVersion 2 Target/Module descriptors, not completed-source inspection. Nonprivate composed FW/HY/MY items in a library Object are public; executable-package items retain their existing crate visibility. Module.Visibility separately controls module exports. Objects remain files and Classes remain source/module groups without runtime scopes.

A sole Kind: "lib", Primary: false target is a library-only Cargo package. It returns declared sources and Cargo.toml, with no config/runtime/start/stop files. IncludeRuntime and executable SETTINGS reject on that package; a library cannot be Primary. Mixed binary/library packages still require exactly one Primary binary and at most one library. An independent path-dependent binary checks public interfaces and shared nominal types in the library regression. This is separate from the Lucid inventory.

Raw AML library targets and explicit native consumers retain this library-only contract. App-constructed Service libraries preserve their current paths, public interfaces and dependency identities. Standalone L Services create no workspace targets; App publication retains its version-1 inventory. See CLI semantics.

Support resources have responsibilities separate from the eighteen segment templates:

ResourceResponsibility
config/config.luStartup configuration.
install/cargo.luCargo manifest.
operate/start.luNative build and launch script.
operate/stop.luExplicit-PID stop script.
runtime/main.luRuntime entry and shutdown.
runtime/host.luHost process, async and trait adapters.
runtime/support.aml, support.jsonDerived runtime composition, source fingerprints and selection index.
runtime/process_unix.luUnix process support.
runtime/process_other.luUnsupported-platform reporting.

The six core nonruntime bundles verify the common manifest, config and start/stop artifact bytes. They do not execute those artifacts, exercise process supervision, or establish L/Lyger Rust output parity by themselves. The CLI builds native Rust workspace members; separate supervised runtime and source-parity tests cover process launch, streams, continuation ownership and cleanup. See the implementation evidence for observed outcomes.

The suite guide owns commands, pins, locks and artifact reporting. Compile generated files without repair or substitution; preserve the validation budgets.

Preserve shared interpreter regressions and L/Lyger integration checks. The acceptance guide owns the full repository gate; the dated ledger records its last verified result. Do not infer a new gate result from documentation edits, broaden or replace the suite incidentally, or update template hashes to accommodate production changes.


Canonical source: builtins/README.md.