# Slovo Roadmap

This roadmap tracks the language contract. Glagol, in `compiler/`, tracks the
compiler implementation inside the same monorepo.

Guiding rule: the manifest wins. A feature is not accepted until it has surface syntax, typed-core meaning, lowering behavior, formatter behavior, diagnostics, and tests.

Long-horizon planning lives in
`.llm/GENERAL_PURPOSE_LANGUAGE_ROADMAP.md`. It defines the experimental
release train from the historical `v2.0.0-beta.1` tag toward and beyond the
first real general-purpose beta Slovo contract.

Current stage: `1.0.0-beta.9`, released on 2026-05-22 as the first post-beta
collection alias unification and generic reservation update. It keeps the `1.0.0-beta` language contract and
includes the `1.0.0-beta.1` tooling hardening release, the `1.0.0-beta.2`
runtime/resource foundation release, the `1.0.0-beta.3` standard-library
stabilization release, the `1.0.0-beta.4` language-usability diagnostics
release, the `1.0.0-beta.5` package/workspace discipline release, and a narrow
`std.net` source facade for blocking loopback TCP client/server primitives over
opaque `i32` handles and concrete `result` families, plus a narrow `std.json`
source facade for compact JSON text construction, plus top-level module-local
transparent aliases for supported concrete target types, plus local alias use
inside the current concrete vector, option, and result facades. JSON parsing,
recursive JSON values, executable generics, generic aliases, parameterized
aliases, cross-module alias visibility, maps/sets, traits, inference,
monomorphization, iterators, DNS, TLS, UDP, async IO, non-loopback binding,
HTTP frameworks, rich host-error ADTs, stable ABI/layout, and a stable
standard-library API freeze remain deferred.

Next stage target: continue from the reserved generic/map/set diagnostics and
collection-unification design pressure without claiming executable generics
until the exact scope is frozen from the manifest and roadmap.

The final experimental precursor scope is `exp-125`, defined in
`.llm/EXP_125_UNSIGNED_U32_U64_NUMERIC_AND_STDLIB_BREADTH_ALPHA.md`. Its
unsigned direct-value flow, parse/format runtime lanes, and matching staged
stdlib helper breadth are now absorbed into `1.0.0-beta`.

The last tagged experimental alpha before beta is `exp-124`, defined in
`.llm/EXP_124_FIXED_ARRAY_ENUM_AND_STRUCT_ELEMENTS_ALPHA.md`.

The previous released experimental alpha contract is `exp-123`, defined in
`.llm/EXP_123_OWNED_VECTOR_BENCHMARK_SUITE_EXTENSION_AND_WHITEPAPER_REFRESH_ALPHA.md`,
for one connected benchmark/publication refresh. It keeps the exp-121
language surface unchanged while refreshing the current whitepaper baseline
and the documented nine-kernel benchmark suite around `math-loop`,
`branch-loop`, `parse-loop`, `array-index-loop`, `string-eq-loop`,
`array-struct-field-loop`, `enum-struct-payload-loop`,
`vec-i32-index-loop`, and `vec-string-eq-loop`, with local-machine evidence
only, no threshold claim, and no beta claim.

The previous released experimental alpha contract is `exp-122`, defined in
`.llm/EXP_122_COMPOSITE_DATA_BENCHMARK_SUITE_EXTENSION_AND_WHITEPAPER_REFRESH_ALPHA.md`,
for one connected benchmark/publication refresh. It kept the exp-121
language surface unchanged while refreshing the earlier whitepaper baseline
and the documented seven-kernel benchmark suite around `math-loop`,
`branch-loop`, `parse-loop`, `array-index-loop`, `string-eq-loop`,
`array-struct-field-loop`, and `enum-struct-payload-loop`, with
local-machine evidence only, no threshold claim, and no beta claim.

The previous released experimental alpha contract is `exp-121`, defined in
`.llm/EXP_121_NON_RECURSIVE_STRUCT_ENUM_PAYLOADS_ALPHA.md`, for one connected
broadening of the enum payload surface. It allows unary enum payload variants
to use current known non-recursive struct types, while keeping exactly one
payload per payload variant, a conservative same-payload-type-per-enum rule
when payload variants are present, existing immutable enum flow through
locals/params/returns/calls/tests/main, existing `match` payload binding and
field access behavior, no enum equality requirement for struct-payload enums,
no direct array/vec/option/result payloads, no recursion, and no beta claim.

The previous released experimental alpha contract is `exp-120`, defined in
`.llm/EXP_120_FIXED_ARRAY_STRUCT_FIELDS_ALPHA.md`, for one connected
broadening of the struct-field surface. It adds direct struct fields over the
current promoted fixed immutable array family `(array i32 N)`, `(array i64 N)`,
`(array f64 N)`, `(array bool N)`, and `(array string N)`, while keeping array
lengths positive only, arrays and structs immutable only, checked indexing on
`i32` expressions only, no field mutation, no array mutation, and no beta
claim.

The earlier released experimental alpha contract is `exp-119`, defined in
`.llm/EXP_119_BENCHMARK_SUITE_EXTENSION_AND_WHITEPAPER_REFRESH_ALPHA.md`, for
one connected benchmark/publication refresh. It keeps the exp-118 language
surface unchanged while refreshing the earlier whitepaper baseline and the
documented five-kernel benchmark suite around `math-loop`, `branch-loop`,
`parse-loop`, `array-index-loop`, and `string-eq-loop`, with local-machine
evidence only, no threshold claim, and no beta claim.

The previous released experimental alpha contract is `exp-118`, defined in
`.llm/EXP_118_STRING_FIXED_ARRAYS_ALPHA.md`, for one connected broadening of
the fixed-array surface. It adds `(array string N)` alongside the earlier
direct scalar array family, while keeping array lengths positive only, arrays
immutable only, checked indexing on `i32` expressions only, arrays in struct
fields out of scope at that earlier boundary, and no beta claim.

The previous released experimental alpha contract is `exp-117`, defined in
`.llm/EXP_117_DIRECT_SCALAR_FIXED_ARRAYS_ALPHA.md`, for one connected
broadening of the fixed-array surface. It adds direct scalar element families
`i64`, `f64`, and `bool` alongside the existing `i32` lane, while keeping
array lengths positive only, arrays immutable only, checked indexing on `i32`
expressions only, string arrays out of scope at that earlier boundary, and no
beta claim.

The previous released experimental alpha contract is `exp-116`, defined in
`.llm/EXP_116_DIRECT_SCALAR_AND_STRING_ENUM_PAYLOADS_ALPHA.md`, for one
connected broadening of the enum payload surface. It adds unary direct `i64`,
`f64`, `bool`, and `string` payload variants alongside payloadless variants
and the existing unary `i32` lane, while keeping exactly one payload per
payload variant, a conservative same-payload-kind-per-enum rule, containers
and composite payloads out of scope, and no beta claim.

The previous released experimental alpha contract is `exp-115`, defined in
`.llm/EXP_115_COMPOSITE_STRUCT_FIELDS_AND_NESTED_STRUCTS_ALPHA.md`, for one
connected broadening of the struct-field surface. It adds current concrete
vec, option, and result families plus current known non-recursive struct
types as direct struct fields, alongside the already-supported direct scalar,
immutable string, and current enum field families, without broadening arrays
as fields, field mutation, recursive/cyclic layouts, adding new runtime
calls, or claiming beta maturity.

The previous released experimental alpha contract is `exp-114`, defined in
`.llm/EXP_114_MUTABLE_COMPOSITE_LOCALS_ALPHA.md`, for one connected
broadening of the local-value surface. It adds same-type mutable whole-value
reassignment for `string`, the current concrete vec families, the current
concrete option/result families, current known struct values, and current enum
values, without broadening arrays, field/element/payload mutation, adding new
runtime calls, or claiming beta maturity.

The previous released experimental alpha contract is `exp-113`, defined in
`.llm/EXP_113_MUTABLE_SCALAR_LOCALS_ALPHA.md`, for one connected broadening
of the local-value surface. It adds direct mutable `bool`, `i64`, and `f64`
locals declared with `var` and reassigned with `set` from already promoted
same-type scalar expressions, without broadening string/vector/option/result/
struct/enum mutation, adding new runtime calls, or claiming beta maturity.

The previous released experimental alpha contract is `exp-112`, defined in
`.llm/EXP_112_IMMUTABLE_BOOL_LOCALS_ALPHA.md`, for one connected broadening
of the local-value surface. It adds direct immutable `bool` locals declared
with `let`, initialized from already promoted bool expressions, and reusable
in existing predicate, return, call, test, and `main` positions, without
adding mutable bool locals, bool assignment, new runtime calls, or a beta
claim.

The previous released experimental alpha contract is `exp-111`, defined in
`.llm/EXP_111_STANDARD_IO_STDIN_SOURCE_HELPERS_ALPHA.md`, for one connected
broadening of the concrete `std.io` facade. It adds
`read_stdin_result`, `read_stdin_option`, `read_stdin_or`,
`read_stdin_i32_result`, `read_stdin_i32_option`, `read_stdin_i32_or_zero`,
`read_stdin_i32_or`, `read_stdin_i64_result`, `read_stdin_i64_option`,
`read_stdin_i64_or_zero`, `read_stdin_i64_or`, `read_stdin_f64_result`,
`read_stdin_f64_option`, `read_stdin_f64_or_zero`, `read_stdin_f64_or`,
`read_stdin_bool_result`, `read_stdin_bool_option`,
`read_stdin_bool_or_false`, and `read_stdin_bool_or` while staying
source-authored over the promoted `std.io.read_stdin_result`,
`std.string.parse_*_result`, and exp-109 bridge helpers only, without
adding compiler-known std names, generics, new runtime calls, or a beta
claim.

The previous released experimental alpha contract is `exp-109`, defined in
`.llm/EXP_109_STANDARD_OPTION_AND_RESULT_BRIDGE_HELPERS_ALPHA.md`, for one
connected broadening of the concrete `std.option` and `std.result` facades.
It adds `some_or_err_i32`, `some_or_err_i64`, `some_or_err_f64`,
`some_or_err_bool`, `some_or_err_string`, `ok_or_none_i32`,
`ok_or_none_i64`, `ok_or_none_string`, `ok_or_none_f64`, and
`ok_or_none_bool` while staying source-authored over the existing concrete
option/result families only, without adding compiler-known std names,
generics, or a beta claim.

The previous released experimental alpha contract is `exp-108`, defined in
`.llm/EXP_108_STANDARD_VEC_STRING_F64_AND_BOOL_PREFIX_AND_SUFFIX_HELPERS_ALPHA.md`,
for one connected broadening of the concrete `std.vec_string`,
`std.vec_f64`, and `std.vec_bool` facades. It adds `starts_with`,
`without_prefix`, `ends_with`, and `without_suffix` to all three modules
while staying source-authored, recursive, and immutable over the existing
vec-string, vec-f64, and vec-bool runtime families only, without adding
compiler-known std names, generics, or a beta claim.

The previous released experimental alpha contract is `exp-106`, defined in
`.llm/EXP_106_STANDARD_VEC_F64_AND_BOOL_OPTION_QUERY_HELPERS_ALPHA.md`, for
one connected broadening of the concrete `std.vec_f64` and `std.vec_bool`
facades. It adds `index_option`, `first_option`, `last_option`,
`index_of_option`, and `last_index_of_option` to both modules while staying
source-authored, recursive, and immutable over the existing vec-f64 and
vec-bool runtime families and the already promoted concrete option families
only, without adding compiler-known std names, generics, edit helpers, or a
beta claim.

The previous released experimental alpha contract is `exp-104`, defined in
`.llm/EXP_104_STANDARD_VEC_BOOL_BASELINE_ALPHA.md`, for the first usable
`std.vec_bool` baseline facade over the sibling concrete `(vec bool)` runtime
family. It freezes the baseline direct wrappers, builder helpers, query
helpers, and the simple real-program helpers `contains` and `count_of`
without widening compiler semantics beyond concrete `(vec bool)` flow and
equality, and without adding generics, option/result helpers, transform/edit
helpers, or a beta claim.

The previous released experimental alpha contract is `exp-102`, defined in
`.llm/EXP_102_STANDARD_OPTION_BOOL_AND_F64_BASELINE_ALPHA.md`, for one
connected broadening of the concrete `std.option` facade and the conservative
option core-language slice. It adds the concrete `(option f64)` and
`(option bool)` helper families to `std/option.slo`, broadens immutable value
flow, extraction, and source-level `match` to those same families, and keeps
the whole slice explicit and concrete without adding compiler-known std names,
generic option semantics, or a beta claim.

The earlier released experimental alpha contract is `exp-101`, defined in
`.llm/EXP_101_STANDARD_VEC_STRING_OPTION_AND_TRANSFORM_HELPERS_ALPHA.md`, for
one connected broadening of the concrete `std.vec_string` facade. It adds the
option-query helpers `index_option`, `first_option`, `last_option`,
`index_of_option`, and `last_index_of_option`, plus the transform helpers
`concat`, `take`, `drop`, `reverse`, and `subvec`, while staying
source-authored, recursive, and immutable over the existing vec-string
runtime family without adding compiler-known std names, generics, edit
helpers, or a beta claim.

The earlier released experimental alpha contract is `exp-100`, defined in
`.llm/EXP_100_STANDARD_OPTION_STRING_BASELINE_ALPHA.md`, for the first
concrete `(option string)` baseline on top of the existing option slice. It
broadens `std/option.slo` with concrete string constructors, observers, and
fallback helpers, and broadens immutable option value flow, payload
extraction, and source-level `match` to `(option string)` without adding
compiler-known std names, generic option semantics, or a beta claim.

The earlier released experimental alpha contract is `exp-99`, defined in
`.llm/EXP_99_STANDARD_VEC_STRING_BASELINE_ALPHA.md`, for the first usable
`std.vec_string` baseline facade over the sibling concrete `(vec string)`
runtime family. It adds the required direct wrappers, builder helpers, query
helpers, and simple real-program helpers as one connected source-authored
slice without widening compiler semantics beyond concrete `(vec string)` flow
and equality, and without adding generics, helper families beyond the frozen
baseline, or a beta claim.

The earlier released experimental alpha contract is `exp-98`, defined in
`.llm/EXP_98_STANDARD_VEC_I64_EDIT_HELPERS_ALPHA.md`, for connected edit
helpers on top of the existing `std.vec_i64` baseline facade. It adds
`insert_at`, `insert_range`, `replace_at`, `replace_range`, `remove_at`, and
`remove_range` as one connected source-authored slice, keeps the full
vec_i64 source family recursive and immutable, and does not add
compiler-known std names, generics, or a beta claim.

The earlier released experimental alpha contract is `exp-97`, defined in
`.llm/EXP_97_STANDARD_VEC_I64_TRANSFORM_HELPERS_ALPHA.md`, for narrow
transform helpers on top of the existing `std.vec_i64` baseline facade. It
adds `concat`, `take`, `drop`, `reverse`, and `subvec` as one connected
source-authored slice, keeps the full vec_i64 source family recursive and
immutable, and does not add compiler-known std names, insert/replace/remove
helpers, generics, or a beta claim.

The earlier released experimental alpha contract is `exp-96`, defined in
`.llm/EXP_96_STANDARD_VEC_I64_OPTION_QUERY_HELPERS_ALPHA.md`, for concrete
option-query helpers on top of the existing `std.vec_i64` baseline facade.
It adds `index_option`, `first_option`, `last_option`, `index_of_option`,
and `last_index_of_option` as one connected source-authored slice, keeps the
module self-contained through raw current `(option i64)` and `(option i32)`
forms instead of `std.option`, keeps the full vec_i64 source family recursive
and immutable, and does not add compiler-known std names, transform/range/edit
helpers, generics, or a beta claim.

The earlier released experimental alpha contract is `exp-95`, defined in
`.llm/EXP_95_STANDARD_OPTION_I64_BASELINE_ALPHA.md`, for the first concrete
`(option i64)` baseline on top of the existing option slice. It broadens
`std/option.slo` with the `i64` constructor, observer, and fallback helper
surface, and broadens immutable option value flow, payload extraction, and
source-level `match` to `(option i64)` without adding compiler-known std
names, generic option semantics, or a beta claim.

The earlier released `exp-94` is defined in
`.llm/EXP_94_STANDARD_VEC_I64_BASELINE_ALPHA.md`, for the first usable
`std.vec_i64` baseline facade over the sibling concrete `(vec i64)` runtime
family. It adds the required direct wrappers, builder helpers, query
helpers, and simple real-program helpers as one connected source-authored
slice without widening compiler semantics or adding new Slovo-side
compiler-known runtime names. It remains experimental maturity, not a beta
claim.

The earlier released `exp-93` is defined in
`.llm/EXP_93_STANDARD_VEC_I32_COUNT_OF_HELPER_ALPHA.md`, for one new public
`std.vec_i32` helper, `count_of`, layered onto that same concrete runtime
family without widening compiler semantics or adding new runtime names. It
remains experimental maturity, not a beta claim.

The earlier released `exp-92` is defined in
`.llm/EXP_92_STANDARD_VEC_I32_WITHOUT_PREFIX_HELPER_ALPHA.md`, for one new
public `std.vec_i32` helper, `without_prefix`, layered onto that same
concrete runtime family without widening compiler semantics or adding new
runtime names. It remains experimental maturity, not a beta claim.

The earlier released `exp-91` is defined in
`.llm/EXP_91_STANDARD_VEC_I32_WITHOUT_SUFFIX_HELPER_ALPHA.md`, for one new
public `std.vec_i32` helper, `without_suffix`, layered onto that same
concrete runtime family without widening compiler semantics or adding new
runtime names. It remains experimental maturity, not a beta claim.

The earlier released `exp-90` is defined in
`.llm/EXP_90_STANDARD_VEC_I32_ENDS_WITH_HELPER_ALPHA.md`, for one new
public `std.vec_i32` helper, `ends_with`, layered onto that same concrete
runtime family without widening compiler semantics or adding new runtime
names. It remains experimental maturity, not a beta claim.

The earlier released `exp-89` is defined in
`.llm/EXP_89_STANDARD_VEC_I32_STARTS_WITH_HELPER_ALPHA.md`, for one new
public `std.vec_i32` helper, `starts_with`, layered onto that same concrete
runtime family without widening compiler semantics or adding new runtime
names. It remains experimental maturity, not a beta claim.

The earlier released `exp-88` is defined in
`.llm/EXP_88_STANDARD_VEC_I32_REPLACE_RANGE_HELPER_ALPHA.md`, for one new
public `std.vec_i32` helper, `replace_range`, layered onto that same
concrete runtime family without widening compiler semantics or adding new
runtime names. It remains experimental maturity, not a beta claim.

The earlier released `exp-87` is defined in
`.llm/EXP_87_STANDARD_VEC_I32_INSERT_RANGE_HELPER_ALPHA.md`, for one new
public `std.vec_i32` helper, `insert_range`, layered onto that same concrete
runtime family without widening compiler semantics or adding new runtime
names. It remains experimental maturity, not a beta claim.

The earlier released `exp-86` is defined in
`.llm/EXP_86_STANDARD_VEC_I32_REMOVE_RANGE_HELPER_ALPHA.md`, for one new
public `std.vec_i32` helper, `remove_range`, layered onto that same concrete
runtime family without widening compiler semantics or adding new runtime
names. It remains experimental maturity, not a beta claim.

The earlier released `exp-85` is defined in
`.llm/EXP_85_STANDARD_VEC_I32_SUBVEC_HELPER_ALPHA.md`, for one new public
`std.vec_i32` helper, `subvec`, layered onto that same concrete runtime
family without widening compiler semantics or adding new runtime names. It
remains experimental maturity, not a beta claim.

The earlier released `exp-84` is defined in
`.llm/EXP_84_STANDARD_VEC_I32_INSERT_HELPER_ALPHA.md`, for one new public
`std.vec_i32` helper, `insert_at`, layered onto that same concrete runtime
family without widening compiler semantics or adding new runtime names. It
remains experimental maturity, not a beta claim.

The earlier released `exp-83` is defined in
`.llm/EXP_83_STANDARD_VEC_I32_REMOVE_HELPER_ALPHA.md`, for one new public
`std.vec_i32` helper, `remove_at`, layered onto that same concrete runtime
family without widening compiler semantics or adding new runtime names. It
remains experimental maturity, not a beta claim.

The earlier released `exp-82` is defined in
`.llm/EXP_82_STANDARD_VEC_I32_REPLACE_HELPER_ALPHA.md`, for one new public
`std.vec_i32` helper, `replace_at`, layered onto that same concrete runtime
family without widening compiler semantics or adding new runtime names. It
remains experimental maturity, not a beta claim.

The earlier released `exp-81` is defined in
`.llm/EXP_81_STANDARD_VEC_I32_RANGE_HELPER_ALPHA.md`, for one new public
`std.vec_i32` helper, `range`, layered onto that same concrete runtime
family without widening compiler semantics or adding new runtime names. It
remains experimental maturity, not a beta claim.

The earlier released `exp-80` is defined in
`.llm/EXP_80_STANDARD_VEC_I32_GENERATED_CONSTRUCTOR_HELPERS_ALPHA.md`, for
narrow generated constructor helpers layered onto the existing `std.vec_i32`
source facade over the promoted `(vec i32)` runtime family.

The earlier released `exp-79` is defined in
`.llm/EXP_79_STANDARD_VEC_I32_TRANSFORM_HELPERS_ALPHA.md`, for narrow
recursive transform helpers layered onto the existing `std.vec_i32` source
facade over the promoted `(vec i32)` runtime family. It remains
experimental maturity, not a beta claim.

The earlier released `exp-78` is defined in
`.llm/EXP_78_STANDARD_CLI_LOCAL_SOURCE_FACADE_ALPHA.md`, for the unchanged
`std.cli` helper surface recorded as the Slovo-side contract for the sibling
Glagol local-source gate over the existing `std.process` and `std.string`
source facades. It remains experimental maturity, not a beta claim.

The earlier released `exp-77` is defined in
`.llm/EXP_77_STANDARD_VEC_I32_OPTION_QUERY_HELPERS_ALPHA.md`, for concrete
option-returning query helpers layered onto the current `std.vec_i32` source
facade over the promoted `(vec i32)` runtime family. It remains experimental
maturity, not a beta claim.

The earlier released `exp-76` is defined in
`.llm/EXP_76_STANDARD_VEC_I32_SOURCE_HELPERS_ALPHA.md`, for a concrete
`std.vec_i32` source facade over the current promoted `(vec i32)` runtime
family. It remains experimental maturity, not a beta claim.

The earlier released `exp-75` is defined in
`.llm/EXP_75_STANDARD_OPTION_CONSTRUCTORS_ALPHA.md`, for source-authored
concrete option constructors over the current promoted `(option i32)` family.
It remains experimental maturity, not a beta claim.
The earlier released `exp-74` is defined in
`.llm/EXP_74_STANDARD_RESULT_CONSTRUCTOR_HELPERS_ALPHA.md`, for
source-authored concrete result constructors over the current promoted result
families. It remains experimental maturity, not a beta claim.

The earlier released `exp-73` is defined in
`.llm/EXP_73_STANDARD_IO_VALUE_HELPERS_ALPHA.md`, for source-authored
value-returning IO print helpers over the current promoted print runtime
calls. It remains experimental maturity, not a beta claim.

The earlier released `exp-72` is defined in
`.llm/EXP_72_STANDARD_CLI_CUSTOM_FALLBACK_HELPERS_ALPHA.md`, for
source-authored typed CLI argument custom-fallback helpers over the current
argument lookup and concrete parse result families. It remains experimental
maturity, not a beta claim.

The earlier released `exp-71` is defined in
`.llm/EXP_71_STANDARD_PROCESS_CUSTOM_FALLBACK_HELPERS_ALPHA.md`, for
source-authored typed process argument custom-fallback helpers over the
current argument lookup and concrete parse result families. It remains
experimental maturity, not a beta claim.

The earlier released `exp-70` is defined in
`.llm/EXP_70_STANDARD_FS_CUSTOM_FALLBACK_HELPERS_ALPHA.md`, for
source-authored typed filesystem read custom-fallback helpers over the current
text-read and concrete parse result families. It remains experimental
maturity, not a beta claim.

The earlier released `exp-69` is defined in
`.llm/EXP_69_STANDARD_ENV_CUSTOM_FALLBACK_HELPERS_ALPHA.md`, for
source-authored typed environment parse custom-fallback helpers over the
current environment lookup and concrete parse result families. It remains
experimental maturity, not a beta claim.

The earlier released `exp-68` is defined in
`.llm/EXP_68_STANDARD_STRING_CUSTOM_FALLBACK_HELPERS_ALPHA.md`, for
source-authored typed string parse custom-fallback helpers over the current
concrete parse result families. It remains experimental maturity, not a beta
claim.

The earlier released `exp-67` is defined in
`.llm/EXP_67_STANDARD_PROCESS_TYPED_HELPERS_ALPHA.md`, for source-authored
typed process argument result/fallback helpers over the current argument
lookup and concrete parse result families. It remains experimental maturity,
not a beta claim.

The earlier released `exp-66` is defined in
`.llm/EXP_66_STANDARD_FS_TYPED_READ_HELPERS_ALPHA.md`, for source-authored
typed filesystem read result/fallback helpers over the current text-read and
concrete parse result families. It remains experimental maturity, not a beta
claim.

The earlier released `exp-65` is defined in
`.llm/EXP_65_STANDARD_ENV_TYPED_HELPERS_ALPHA.md`, for source-authored typed
environment parse result/fallback helpers over the current environment lookup
and concrete parse result families. It remains experimental maturity, not a
beta claim.

The earlier released `exp-64` is defined in
`.llm/EXP_64_STANDARD_NUM_FALLBACK_HELPERS_ALPHA.md`, for source-authored
checked conversion fallback helpers over the current numeric result
families. It remains experimental maturity, not a beta claim.

The earlier released `exp-63` is defined in
`.llm/EXP_63_STANDARD_FS_FALLBACK_HELPERS_ALPHA.md`, for source-authored
filesystem fallback/status helpers over the current `(result string i32)` and
`(result i32 i32)` families. It remains experimental maturity, not a beta
claim.

The earlier released `exp-62` is defined in
`.llm/EXP_62_STANDARD_ENV_FALLBACK_HELPERS_ALPHA.md`, for source-authored
environment presence/fallback helpers over the current `(result string i32)`
family. It remains experimental maturity, not a beta claim.

The earlier released `exp-61` is defined in
`.llm/EXP_61_STANDARD_PROCESS_FALLBACK_HELPERS_ALPHA.md`, for source-authored
process argument fallback helpers over the current `(result string i32)`
family. It remains experimental maturity, not a beta claim.

The earlier released `exp-60` is defined in
`.llm/EXP_60_STANDARD_STRING_FALLBACK_HELPERS_ALPHA.md`, for source-authored
string parse fallback helpers over the current concrete parse result
families. It remains experimental maturity, not a beta claim.

The earlier released `exp-59` is defined in
`.llm/EXP_59_HOSTED_BUILD_OPTIMIZATION_AND_BENCHMARK_PUBLICATION_ALPHA.md`,
for the earlier benchmark/publication baseline paired with Glagol exp-59. It
keeps the exp-58 language surface unchanged and remains experimental
maturity, not a beta claim.

The earlier released `exp-58` is defined in
`.llm/EXP_58_BOOLEAN_LOGIC_ALPHA.md`, for boolean `and`, `or`, and `not`
forms lowered through existing `if` semantics.

The earlier released `exp-57` is defined in
`.llm/EXP_57_INTEGER_BITWISE_ALPHA.md`, for explicit integer bitwise heads
over same-width `i32` and `i64` operands plus source-authored `std.math`
bitwise wrappers.

The earlier released `exp-56` is defined in
`.llm/EXP_56_INTEGER_REMAINDER_ALPHA.md`, for integer remainder `%` over
same-width `i32` and `i64` operands plus source-authored `std.math`
remainder/even/odd helpers.

The earlier released `exp-55` is defined in
`.llm/EXP_55_RESULT_F64_BOOL_SOURCE_FLOW_ALPHA.md`, for concrete `f64` and
`bool` result constructors and source `match` payload bindings.

The earlier released `exp-54` is defined in
`.llm/EXP_54_STANDARD_CLI_TYPED_ARGUMENTS_ALPHA.md`, for typed argument parse
helpers in the staged CLI facade module.

The earlier released `exp-53` is defined in
`.llm/EXP_53_STANDARD_CLI_SOURCE_FACADE_ALPHA.md`, for explicit project-mode
source search of the staged CLI facade module.

The earlier released `exp-52` is defined in
`.llm/EXP_52_STANDARD_PROCESS_FACADE_SOURCE_SEARCH_ALPHA.md`, for explicit
project-mode source search of the staged process facade module.

The earlier released `exp-51` is defined in
`.llm/EXP_51_STANDARD_LIBRARY_PATH_LIST_ALPHA.md`, for ordered
`SLOVO_STD_PATH` discovery of explicit standard-library source imports.

The earlier released `exp-50` is defined in
`.llm/EXP_50_INSTALLED_STANDARD_LIBRARY_DISCOVERY_ALPHA.md`, for installed
toolchain discovery of explicit standard-library source imports.

The earlier released `exp-49` is defined in
`.llm/EXP_49_STANDARD_IO_FACADE_SOURCE_SEARCH_ALPHA.md`, for explicit
project-mode source search of the staged IO facade module.

The earlier released `exp-48` is defined in
`.llm/EXP_48_STANDARD_CORE_FACADE_SOURCE_SEARCH_ALPHA.md`, for explicit
project-mode source search of staged core facade modules.

The earlier released `exp-47` is defined in
`.llm/EXP_47_STANDARD_HOST_FACADE_SOURCE_SEARCH_ALPHA.md`, for explicit
project-mode source search of staged host facade modules.

The earlier released `exp-46` is defined in
`.llm/EXP_46_WORKSPACE_STANDARD_SOURCE_SEARCH_ALPHA.md`, for explicit
workspace-package standard source search.

The earlier released `exp-45` is defined in
`.llm/EXP_45_STANDARD_RESULT_OPTION_SOURCE_SEARCH_ALPHA.md`, for explicit
project-mode `std.result` and `std.option` source search.

The earlier released `exp-44` is defined in
`.llm/EXP_44_STANDARD_LIBRARY_SOURCE_SEARCH_ALPHA.md`, for explicit
project-mode `std.math` source search.

The earlier released `exp-43` is defined in
`.llm/EXP_43_TECHNICAL_WHITEPAPERS_AND_SKILLS_ALPHA.md`, for technical
whitepapers, PDF publication artifacts, and beta language-design skills.

The earlier released `exp-42` is defined in
`.llm/EXP_42_HOT_LOOP_BENCHMARK_MODE_ALPHA.md`, for hot-loop benchmark mode
alignment. It remains experimental maturity, not a beta claim, and does not
change the exp-39 language surface.

The earlier released `exp-41`, Lisp Benchmark Comparison Alpha, is defined in
`.llm/EXP_41_LISP_BENCHMARK_COMPARISON_ALPHA.md` for Lisp-family benchmark
comparison alignment.

The earlier released `exp-40`, Benchmark Suite And License Alpha, is defined
in `.llm/EXP_40_BENCHMARK_SUITE_AND_LICENSE_ALPHA.md` for benchmark-suite
alignment, project licensing, and release naming criteria.

The earlier released `exp-39`, Standard Math Extensions And Benchmark
Scaffold Alpha, is defined in
`.llm/EXP_39_STANDARD_MATH_EXTENSIONS_AND_BENCHMARK_SCAFFOLD_ALPHA.md` for
source-authored math helper extensions in `std/math.slo` and matching Glagol
benchmark scaffold gates.

The earlier released `exp-38`, Standard Host Source Facades Alpha, is defined
in `.llm/EXP_38_STANDARD_HOST_SOURCE_FACADES_ALPHA.md` and remains part of the
experimental history.

The earlier released `exp-37`, Standard Time Source Facade Alpha, is defined
in `.llm/EXP_37_STANDARD_TIME_SOURCE_FACADE_ALPHA.md` and remains part of the
experimental history.

The earlier released `exp-36`, Standard Option Source Helpers Alpha, is
defined in `.llm/EXP_36_STANDARD_OPTION_SOURCE_HELPERS_ALPHA.md` and remains
part of the experimental history.
The earlier released `exp-35`, Standard Result Bool Source Helpers Alpha, is
defined in `.llm/EXP_35_STANDARD_RESULT_BOOL_SOURCE_HELPERS_ALPHA.md` and
remains part of the experimental history.

The earlier released `exp-34`, String Parse Bool Result Alpha, is defined in
`.llm/EXP_34_STRING_PARSE_BOOL_RESULT_ALPHA.md` and remains part of the
experimental history.

The earlier released `exp-33`, Standard Result Source Helpers Alpha, is
defined in `.llm/EXP_33_STANDARD_RESULT_SOURCE_HELPERS_ALPHA.md` and remains
part of the experimental history.

The earlier released `exp-32`, Standard Math Source Helpers Alpha, is defined
in `.llm/EXP_32_STANDARD_MATH_SOURCE_HELPERS_ALPHA.md` and remains part of
the experimental history.

The earlier released `exp-31`, Checked F64 To I64 Result Alpha, is defined in
`.llm/EXP_31_CHECKED_F64_TO_I64_RESULT_ALPHA.md` and remains part of the
experimental history.

The earlier released `exp-30`, Standard Library Source Layout Alpha, is
defined in `.llm/EXP_30_STANDARD_LIBRARY_SOURCE_LAYOUT_ALPHA.md` and remains
part of the experimental history.

The earlier released `exp-29`, Numeric Struct Fields Alpha, is defined in
`.llm/EXP_29_NUMERIC_STRUCT_FIELDS_ALPHA.md` and remains part of the
experimental history.

The current released experimental alignment is `exp-14`, Standard Runtime
Conformance Alignment, defined in
`.llm/EXP_14_STANDARD_RUNTIME_CONFORMANCE_ALIGNMENT.md`. It adds no source
syntax, type forms, runtime APIs, compiler-known `std.*` names, standard
library functions, manifest schema version, ABI/layout promise, runtime
headers/libraries, or beta maturity.

Release maturity policy lives in `.llm/RELEASE_MATURITY_POLICY.md`. All
current releases are experimental maturity; beta is reserved for the
general-purpose threshold.

## Definition Of Supported

An example is compiler-supported only when Glagol can parse it, lower it, type-check it, emit LLVM for it, and the behavior is covered by an automated test.

Partial compiler recognition does not count as support. A checked form that can
still reach a backend panic, lacks diagnostics, or lacks tests remains a design
target.

Current supported subset:

- `examples/supported/add.slo`
- `examples/supported/top-level-test.slo`
- `examples/supported/local-variables.slo`
- `examples/supported/composite-locals.slo`
- `examples/supported/composite-struct-fields.slo`
- `examples/supported/if.slo`
- `examples/supported/while.slo`
- `examples/supported/struct.slo`
- `examples/supported/struct-value-flow.slo`
- `examples/supported/array.slo`
- `examples/supported/array-value-flow.slo`
- `examples/supported/array-direct-scalars.slo`
- `examples/supported/array-direct-scalars-value-flow.slo`
- `examples/supported/array-string.slo`
- `examples/supported/array-string-value-flow.slo`
- `examples/supported/array-struct-fields.slo`
- `examples/supported/enum-payload-structs.slo`
- `examples/supported/option-result.slo`
- `examples/supported/option-result-flow.slo`
- `examples/supported/option-result-payload.slo`
- `examples/supported/option-result-match.slo`
- `examples/supported/string-print.slo`
- `examples/supported/string-value-flow.slo`
- `examples/supported/print-bool.slo`
- `examples/supported/standard-runtime.slo`
- `examples/supported/unsafe.slo`
- `examples/supported/time-sleep.slo`
- `examples/supported/string-parse-i32-result.slo`
- `examples/supported/result-helpers.slo`
- `examples/supported/enum-payload-i32.slo`
- `examples/supported/enum-payload-direct-scalars.slo`
- `examples/supported/enum-struct-fields.slo`
- `examples/supported/primitive-struct-fields.slo`
- `examples/supported/f64-numeric-primitive.slo`
- `examples/supported/i64-numeric-primitive.slo`
- `examples/supported/numeric-widening-conversions.slo`
- `examples/supported/checked-i64-to-i32-conversion.slo`
- `examples/supported/integer-to-string.slo`
- `examples/supported/string-parse-i64-result.slo`
- `examples/supported/f64-to-string.slo`
- `examples/supported/f64-to-i32-result.slo`
- `examples/supported/string-parse-f64-result.slo`
- `examples/supported/numeric-struct-fields.slo`
- `examples/supported/f64-to-i64-result.slo`
- `examples/supported/string-parse-bool-result.slo`
- `(module name)`
- top-level `(struct Name (field i32)...)`
- top-level `(fn ...)`
- top-level `(test "name" body... final-expression)`
- explicit `i32` parameters and `i32` returns, plus direct `(option i32)` and
  `(result i32 i32)` constructor returns
- integer literals, parameter references, binary `+`, user function calls,
  legacy compiler/runtime compatibility alias `print_i32`, equality
  comparison `=`, ordering comparison `<`, and final-expression returns
- local `i32` bindings with `let` and `var`, local references after
  declaration, and mutable local assignment with `set`
- value-producing `if`
- first-pass `while` as a non-final sequential body form
- first-pass struct construction and immediate field access
- first v1 struct value flow through immutable locals, parameters, returns,
  calls returning structs, and stored field access
- fixed direct scalar array constructors over `i32`, `i64`, `f64`, and `bool`,
  immutable array locals, and literal checked indexing
- fixed direct scalar array value flow through immutable array locals
  initialized from matching array-valued expressions, fixed array parameters,
  returns, calls returning arrays, and runtime-checked dynamic indexing
- first-pass `i32` option/result constructors as direct function returns
- first v1 option/result value flow through immutable locals, parameters,
  calls returning option/result values, and `is_some` / `is_none` / `is_ok` /
  `is_err` tag observation
- first v1 trap-based `i32` option/result payload extraction with
  `unwrap_some`, `unwrap_ok`, and `unwrap_err`
- v1.4 source-level `match` for existing `(option i32)` and
  `(result i32 i32)` values, with exhaustive arms, immutable arm-scoped
  payload bindings, one-or-more expression arm bodies, and common arm result
  types
- exp-10 concrete `(result string i32)` with
  the same narrow result flow, observers, unwraps, and `match` shape used by
  existing `(result i32 i32)` support
- exp-15 preferred result helper standard names `std.result.is_ok`,
  `std.result.is_err`, `std.result.unwrap_ok`, and `std.result.unwrap_err`
  for only `(result i32 i32)`, `(result i64 i32)`, and
  `(result string i32)`, plus `(result f64 i32)` where promoted by exp-28,
  with legacy unqualified result helpers retained as compatibility syntax
- exp-16 user-defined enum variants carrying exactly one `i32` payload,
  qualified unary constructors, immutable arm-local payload bindings in
  exhaustive enum `match`, enum value flow through locals, parameters,
  returns, calls, tests, and `main`, and same-enum tag-plus-payload equality
- exp-120 direct struct fields over fixed immutable arrays `(array i32 N)`,
  `(array i64 N)`, `(array f64 N)`, `(array bool N)`, and `(array string N)`,
  with immutable struct flow and checked indexing after field access
- exp-121 unary enum payload variants over current known non-recursive struct
  types, with one payload per payload variant, one payload type per enum when
  payload variants are present, immutable enum flow, and `match` payload
  binding exposing existing field access behavior
- exp-118 fixed immutable arrays over `string`, with positive literal
  lengths, direct construction, immutable local value flow, parameters,
  returns, calls returning arrays, and checked indexing with `i32`
  expressions only
- exp-117 fixed immutable arrays over direct scalar element families `i32`,
  `i64`, `f64`, and `bool`, with positive literal lengths, direct
  construction, immutable local value flow, parameters, returns, calls
  returning arrays, and checked indexing with `i32` expressions only
- exp-116 user-defined enum variants carrying exactly one direct `i64`,
  `f64`, `bool`, or `string` payload in addition to the existing unary `i32`
  lane, with the same one-binding exhaustive `match` shape, immutable value
  flow, and same-enum tag-plus-payload equality, while keeping one direct
  payload kind per enum when payload variants are present
- exp-18 enum-typed struct fields using the current exp-4 payloadless and
  exp-16 unary `i32` enum surfaces, with struct construction, immutable
  struct flow, field access, same-enum equality on field access, and enum
  match on field access
- exp-19 primitive struct fields using direct `bool` and immutable `string`
  field types alongside direct `i32` and exp-18 enum fields, with struct
  construction, immutable struct flow, field access, bool predicate use,
  string equality, and `std.string.len`
- exp-112 immutable bool locals using direct immutable `let` locals declared
  as `bool`, initialized from already promoted bool expressions, and flowing
  into existing predicate, return, call, test, and `main` positions
- exp-113 mutable scalar locals using direct mutable `var` locals declared as
  `bool`, `i64`, and `f64`, plus same-type `set` reassignment from already
  promoted scalar expressions
- exp-114 mutable composite locals using same-type whole-value `var` / `set`
  reassignment for `string`, current concrete vec families, current concrete
  option/result families, current known struct values, and current enum values
- exp-115 composite struct fields and nested structs using direct struct field
  declarations over current concrete vec families, current concrete
  option/result families, and current known non-recursive struct types,
  alongside the already supported direct scalar, immutable string, and current
  enum field families
- exp-20 f64 numeric primitive using direct `f64` parameters, returns,
  immutable locals, calls, decimal literals, same-type `f64` arithmetic and
  comparison, and `std.io.print_f64`
- exp-21 i64 numeric primitive using direct `i64` parameters, returns,
  immutable locals, calls, explicit signed decimal `i64` literal atoms,
  same-type `i64` arithmetic and comparison, and `std.io.print_i64`
- exp-22 numeric widening conversions using explicit
  `std.num.i32_to_i64 : (i32) -> i64`,
  `std.num.i32_to_f64 : (i32) -> f64`, and
  `std.num.i64_to_f64 : (i64) -> f64` calls over the existing numeric
  primitives
- exp-23 checked i64-to-i32 conversion using explicit
  `std.num.i64_to_i32_result : (i64) -> (result i32 i32)`, returning `ok`
  for signed `i32` range values and `err 1` for out-of-range values
- exp-24 integer to string formatting using explicit
  `std.num.i32_to_string : (i32) -> string` and
  `std.num.i64_to_string : (i64) -> string`, returning decimal signed ASCII
  text with `-` only for negative values and no leading `+`
- exp-25 string parse i64 result using explicit
  `std.string.parse_i64_result : (string) -> (result i64 i32)`, returning
  `ok value` for in-range ASCII signed decimal `i64` text and `err 1` for
  parse failure or out-of-range input
- exp-26 f64 to string formatting using explicit
  `std.num.f64_to_string : (f64) -> string`, returning finite decimal ASCII
  text for promoted finite `f64` values
- exp-27 checked f64-to-i32 result conversion using explicit
  `std.num.f64_to_i32_result : (f64) -> (result i32 i32)`, returning `ok`
  value only for finite, exactly integral inputs inside the signed `i32` range
  and `err 1` for non-finite, fractional, or out-of-range input
- exp-28 string parse f64 result using explicit
  `std.string.parse_f64_result : (string) -> (result f64 i32)`, returning
  `ok value` for complete finite ASCII decimal `f64` text and `err 1` for
  ordinary parse failure, non-finite text, trailing or leading unsupported
  characters, or out-of-domain input
- exp-29 numeric struct fields using direct immutable `i64` and finite `f64`
  field types alongside already supported direct `i32`, `bool`, immutable
  `string`, and current enum fields, with constructors, immutable struct flow,
  field access, existing same-type numeric arithmetic/comparison, and existing
  numeric print/format helpers
- exp-30 standard library source layout using `std/` as the staged source home
  for standard library modules and examples, including narrow source-authored
  `std/math.slo` helpers and source wrappers over already promoted
  compiler-known calls, without automatic `std` imports or new
  compiler-known `std.*` names
- exp-31 checked f64-to-i64 result conversion using explicit
  `std.num.f64_to_i64_result : (f64) -> (result i64 i32)`, returning `ok`
  value only for finite, exactly integral inputs inside the signed `i64` range
  and `err 1` for non-finite, fractional, or out-of-range input
- exp-32 standard math source helpers in staged `std/math.slo`, adding
  source-authored `i64` and finite `f64` `abs`, `min`, `max`, `clamp`, and
  `square` coverage without new compiler-known `std.*` runtime names
- exp-39 standard math extension helpers in staged `std/math.slo`, adding
  source-authored `neg`, `cube`, zero/positive/negative predicates, and
  inclusive `in_range` coverage for `i32`, `i64`, and finite `f64` without
  broad math or benchmark-performance claims
- exp-33 standard result source helpers in staged `std/result.slo`, adding
  concrete `is_err_*` and `unwrap_err_*` wrappers for already promoted
  concrete result families plus `unwrap_or_i32`, `unwrap_or_i64`,
  `unwrap_or_string`, and `unwrap_or_f64` without new compiler-known `std.*`
  runtime names
- exp-34 string parse bool result using explicit
  `std.string.parse_bool_result : (string) -> (result bool i32)`, returning
  `ok true` for exactly `true`, `ok false` for exactly `false`, and `err 1`
  for empty input, uppercase/mixed-case text, leading/trailing whitespace,
  numeric text, or any other text
- exp-35 standard result bool source helpers in staged `std/result.slo`,
  adding `is_ok_bool`, `is_err_bool`, `unwrap_ok_bool`, `unwrap_err_bool`,
  and `unwrap_or_bool` for `(result bool i32)` without new compiler-known
  `std.*` runtime names, generic result helpers, or stable ABI/layout claims
- exp-36 standard option source helpers in staged `std/option.slo`, adding
  `is_some_i32`, `is_none_i32`, `unwrap_some_i32`, and `unwrap_or_i32` for
  `(option i32)` without new compiler-known `std.*` runtime names, generic
  option helpers, automatic `std` imports/search, or stable ABI/layout claims
- exp-37 standard time source facade in staged `std/time.slo`, adding
  `monotonic_ms` and `sleep_ms_zero` wrappers over the already released exp-8
  time calls without new compiler-known `std.*` runtime names, automatic
  `std` imports/search, wall-clock/calendar/timezone APIs, high-resolution
  timers, async timers, cancellation, scheduling guarantees, or stable
  ABI/layout claims
- first runtime string slice for immutable source string literals passed
  directly to legacy compiler/runtime compatibility alias `print_string`,
  which prints the string plus a newline and returns builtin `unit`
- v1.2 immutable string value flow through `let` locals, parameters, returns,
  calls returning strings, string equality, string byte length through
  `string_len`, and top-level tests using string equality
- legacy compiler/runtime compatibility alias `print_bool`, which prints
  `true` or `false` plus a newline and returns builtin `unit`
- v1.5 standard-runtime alpha names `std.io.print_i32`,
  `std.io.print_string`, `std.io.print_bool`, and `std.string.len`, with
  legacy `print_i32`, `print_string`, `print_bool`, and `string_len` retained
  as compatibility aliases
- exp-8 host time/sleep alpha names `std.time.monotonic_ms: () -> i32` and
  `std.time.sleep_ms: (i32) -> unit`, with deterministic `sleep_ms 0` and
  only structural/non-negative `monotonic_ms` checks in conformance fixtures
- lexical `unsafe` expression blocks containing otherwise supported safe body
  forms, plus `UnsafeRequired` / `UnsupportedUnsafeOperation` diagnostics for
  raw unsafe operation heads reserved by v1.6: `alloc`, `dealloc`, `load`,
  `store`, `ptr_add`, `unchecked_index`, `reinterpret`, and `ffi_call`

Current exp-1 fixture support:

- `examples/supported/owned-string-concat.slo`
- `examples/formatter/owned-string-concat.slo`
- compiler-known `std.string.concat` with signature
  `(string, string) -> string`, producing immutable runtime-owned strings

Current exp-2 fixture support:

- `examples/supported/vec-i32.slo`
- `examples/formatter/vec-i32.slo`
- one concrete growable vector type `(vec i32)`
- compiler-known `std.vec.i32.empty`, `std.vec.i32.append`,
  `std.vec.i32.len`, and `std.vec.i32.index`
- vector equality with `=`

These are current compiler-supported exp-2 fixtures.

Current exp-3 fixture support:

- `examples/supported/host-io.slo`
- `examples/formatter/host-io.slo`
- compiler-known `std.io.eprint`, `std.process.argc`, `std.process.arg`,
  `std.env.get`, `std.fs.read_text`, and `std.fs.write_text`
- process argument out-of-range and file read failure as exact runtime traps
- missing environment variables as empty strings
- text file write status `0` on success and `1` on host failure

These are current compiler-supported exp-3 fixtures.

Current exp-8 release fixtures:

- `examples/supported/time-sleep.slo`
- `examples/formatter/time-sleep.slo`
- compiler-known `std.time.monotonic_ms: () -> i32`
- compiler-known `std.time.sleep_ms: (i32) -> unit`
- non-negative host monotonic elapsed milliseconds with implementation-owned
  epoch
- deterministic `sleep_ms 0`
- no positive-duration timing assertion

These are current compiler-supported exp-8 fixtures aligned by the released
exp-14 conformance release.

Current exp-12 release fixtures:

- `examples/supported/stdin-result.slo`
- `examples/formatter/stdin-result.slo`
- compiler-known `std.io.read_stdin_result: () -> (result string i32)`
- remaining stdin text as `ok`
- ordinary EOF with no bytes as `ok ""`
- ordinary host/input failure as `err 1`
- deterministic-enough test-runner behavior through an implementation-owned
  fixed `ok` string

These are current compiler-supported exp-12 fixtures.

Current exp-13 release fixtures:

- `examples/supported/string-parse-i32-result.slo`
- `examples/formatter/string-parse-i32-result.slo`
- compiler-known
  `std.string.parse_i32_result: (string) -> (result i32 i32)`
- entire ASCII decimal signed `i32` parsing with optional leading `-`
- success as `(ok i32 i32 value)`
- ordinary parse failure as `(err i32 i32 1)`
- structural composition with `std.io.read_stdin_result` without assuming a
  particular stdin payload

These are current compiler-supported exp-13 fixtures.

Current exp-15 released fixtures:

- `examples/supported/result-helpers.slo`
- `examples/formatter/result-helpers.slo`
- compiler-known `std.result.is_ok` and `std.result.is_err` for
  `(result i32 i32)` and `(result string i32)`
- compiler-known `std.result.unwrap_ok` returning `i32` for
  `(result i32 i32)` and `string` for `(result string i32)`
- compiler-known `std.result.unwrap_err` returning `i32` for both supported
  result families
- legacy unqualified `is_ok`, `is_err`, `unwrap_ok`, and `unwrap_err` remain
  compatibility syntax where already supported

These are released Slovo-side exp-15 fixtures with matching Glagol gates.

Current exp-10 compiler-supported fixtures:

- `examples/supported/host-io-result.slo`
- `examples/formatter/host-io-result.slo`
- concrete `(result string i32)` values
- compiler-known `std.process.arg_result`, `std.env.get_result`,
  `std.fs.read_text_result`, and `std.fs.write_text_result`
- ordinary host failure as `err 1`
- exp-3 calls unchanged

Current exp-11 release fixtures:

- `examples/supported/random.slo`
- `examples/formatter/random.slo`
- compiler-known `std.random.i32: () -> i32`
- non-negative implementation-owned random `i32` values for basic CLI use
- exact unavailable trap:
  `slovo runtime error: random i32 unavailable`

Current exp-4 fixture support:

- `examples/supported/enum-basic.slo`
- `examples/formatter/enum-basic.slo`
- payloadless `(enum Name VariantA VariantB ...)` declarations with at least
  one variant
- zero-argument qualified constructors such as `(Name.VariantA)`
- enum values through immutable locals, parameters, returns, calls, equality,
  and top-level tests
- exhaustive payloadless enum `match` arms with common final result types

These are current compiler-supported exp-4 fixtures.

Current exp-16 fixture support:

- `examples/supported/enum-payload-i32.slo`
- `examples/formatter/enum-payload-i32.slo`
- enum declarations mixing payloadless variants and unary `i32` payload
  variants
- zero-argument constructors for payloadless variants and qualified unary
  constructors for payload variants
- enum values through immutable locals, parameters, returns, calls, equality,
  top-level tests, and `main`
- exhaustive enum `match` arms with immutable arm-local payload bindings for
  payload variants
- same-enum equality by tag for payloadless variants and by tag plus payload
  for payload variants

These are released experimental exp-16 fixtures.

Current exp-121 fixture support:

- `examples/supported/enum-payload-structs.slo`
- `examples/formatter/enum-payload-structs.slo`
- unary enum payload variants over current known non-recursive struct types
- one payload per payload variant and one payload type per enum when payload
  variants are present
- qualified constructors, immutable enum locals, parameters, returns, calls,
  tests, and `main`
- exhaustive `match` payload binding exposing the struct payload for existing
  field access and checked indexing through array-bearing struct fields

These are released experimental exp-121 fixtures.

Current exp-120 fixture support:

- `examples/supported/array-struct-fields.slo`
- `examples/formatter/array-struct-fields.slo`
- direct struct field declarations over fixed immutable arrays with element
  families `i32`, `i64`, `f64`, `bool`, and `string`
- struct construction from matching fixed-array expressions
- immutable struct locals, parameters, returns, calls, tests, and `main`
  for structs carrying those field types
- field access returning the declared fixed-array type for existing checked
  indexing with `i32` expressions

These are released experimental exp-120 fixtures.

Current exp-118 fixture support:

- `examples/supported/array-string.slo`
- `examples/formatter/array-string.slo`
- `examples/supported/array-string-value-flow.slo`
- `examples/formatter/array-string-value-flow.slo`
- fixed immutable arrays over `string`
- positive literal lengths only, immutable arrays only, and checked indexing
  with `i32` expressions only
- direct constructors, immutable array locals, parameters, returns, calls
  returning arrays, top-level tests, and `main`

These are released experimental exp-118 fixtures.

Current exp-117 fixture support:

- `examples/supported/array-direct-scalars.slo`
- `examples/formatter/array-direct-scalars.slo`
- `examples/supported/array-direct-scalars-value-flow.slo`
- `examples/formatter/array-direct-scalars-value-flow.slo`
- fixed immutable arrays over direct scalar element families `i32`, `i64`,
  `f64`, and `bool`
- positive literal lengths only, immutable arrays only, and checked indexing
  with `i32` expressions only
- direct constructors, immutable array locals, parameters, returns, calls
  returning arrays, top-level tests, and `main`

These are released experimental exp-117 fixtures.

Current exp-116 fixture support:

- `examples/supported/enum-payload-direct-scalars.slo`
- `examples/formatter/enum-payload-direct-scalars.slo`
- enum declarations mixing payloadless variants and unary direct `i64`,
  `f64`, `bool`, or `string` payload variants
- one payload per payload variant, with one direct payload kind per enum when
  payload variants are present
- zero-argument constructors for payloadless variants and qualified unary
  constructors for payload variants
- enum values through immutable locals, parameters, returns, calls, equality,
  top-level tests, and `main`
- exhaustive enum `match` arms with one immutable arm-local payload binding
  for payload variants

These are released experimental exp-116 fixtures.

Released exp-17 project contract fixture:

- `examples/projects/enum-imports/`
- export lists may include top-level enum names in project/workspace modules
- import lists may import exported enum names
- imported enum types may be used in function signatures, immutable locals,
  calls/returns, equality, exhaustive enum matches, and qualified
  constructors
- the enum surface remains exactly exp-4 payloadless variants plus exp-16
  unary `i32` payload variants

This is a released experimental exp-17 fixture. It does not claim beta
maturity or widen manifests, packages, enum payloads, generics, containers,
mutation, printing, ordering, hashing, reflection, or stable ABI/layout.

Current exp-18 fixture support:

- `examples/supported/enum-struct-fields.slo`
- `examples/formatter/enum-struct-fields.slo`
- direct struct fields whose types are current user-defined enum names
- struct construction with payloadless and unary `i32` enum field values
- immutable struct locals, parameters, returns, calls, tests, and `main`
- field access returning enum values
- same-enum equality and exhaustive enum `match` on field access

This is a released experimental exp-18 fixture. It does not claim beta
maturity or widen enum payloads, containers, nested structs, mutation,
printing, ordering, hashing, reflection, import behavior, manifest schema,
package-manager behavior, or stable ABI/layout.

Current exp-19 fixture support:

- `examples/supported/primitive-struct-fields.slo`
- `examples/formatter/primitive-struct-fields.slo`
- direct struct fields whose types are `i32`, `bool`, or immutable `string`
- struct construction with `i32`, `bool`, and immutable `string` field values
- immutable struct locals, parameters, returns, calls, tests, and `main`
- field access returning primitive values
- bool field access in predicate/test positions
- string field equality and `std.string.len` on field access

This is a released experimental exp-19 fixture. It does not claim beta
maturity or widen arrays, vectors, options, results, nested structs, mutation,
string ownership/cleanup guarantees, broader string operations, printing,
package/import behavior, manifest schema, generics, methods, traits, or stable
ABI/layout.

Current exp-115 fixture support:

- `examples/supported/composite-struct-fields.slo`
- `examples/formatter/composite-struct-fields.slo`
- direct struct field declarations using current concrete vec families
- direct struct field declarations using current concrete option/result
  families
- direct struct field declarations using current known non-recursive struct
  types
- coexistence with the already supported direct `i32`, `bool`, immutable
  `string`, `i64`, finite `f64`, and current enum field families
- immutable struct locals, parameters, returns, calls, tests, and `main`
  for structs carrying those fields
- field access returning those composite field values for use with existing
  vec indexing, option/result `match`, string/number helpers, enum `match`,
  and nested struct helper flow

This is a released experimental exp-115 fixture alignment. It does not claim
beta maturity or add arrays as struct fields, field mutation, recursive/cyclic
layouts, imports, runtime names, or stable ABI/layout.

Current exp-114 fixture support:

- `examples/supported/composite-locals.slo`
- `examples/formatter/composite-locals.slo`
- same-type mutable whole-value `var` / `set` reassignment for `string`,
  current concrete vec families, current concrete option/result families,
  current known struct values, and current enum values
- fixed arrays remain immutable and field/element/payload mutation stays out
  of scope

This is a released experimental exp-114 fixture alignment. It does not claim
beta maturity or add mutable arrays, field mutation, vector element mutation,
option/result payload mutation, enum payload mutation, imports, runtime names,
or stable ABI/layout.

Current exp-113 fixture support:

- `examples/supported/local-variables.slo`
- `examples/formatter/local-variables.slo`
- direct mutable `var` locals declared as `bool`, `i64`, and `f64`
- same-type `set` reassignment from already promoted scalar expressions for
  those declared local types
- the fixture pair retains the earlier direct `i32` local flow and exp-112
  immutable `bool` local coverage

This is a released experimental exp-113 fixture alignment. It does not claim
beta maturity or add mutable `string` locals, vector mutation, option/result
mutation, struct or enum mutation, mixed-type assignment, imports, runtime
names, or stable ABI/layout.

Current exp-20 fixture support:

- `examples/supported/f64-numeric-primitive.slo`
- `examples/formatter/f64-numeric-primitive.slo`
- direct `f64` function parameters and returns
- immutable `let` locals declared as `f64`
- calls passing and returning `f64`
- decimal `f64` literals in `f64` contexts
- same-type `f64` `+`, `-`, `*`, `/`, `=`, `<`, `>`, `<=`, and `>=`
- `std.io.print_f64`
- top-level tests and `main` returning `i32`

This is a released experimental exp-20 fixture. It does not claim beta
maturity or widen `f32`, wider/common integer types, char/bytes/decimal,
numeric casts, mixed numeric arithmetic, f64 collections, f64 enum payloads,
f64 struct fields, parsing, random floats, broader math APIs, manifest schema,
or stable ABI/layout.

Current exp-21 fixture support:

- `examples/supported/i64-numeric-primitive.slo`
- `examples/formatter/i64-numeric-primitive.slo`
- direct `i64` function parameters and returns
- immutable `let` locals declared as `i64`
- calls passing and returning `i64`
- explicit signed decimal `i64` literal atoms with the `i64` suffix
- same-type `i64` `+`, `-`, `*`, `/`, `=`, `<`, `>`, `<=`, and `>=`
- `std.io.print_i64`
- top-level tests and `main` returning `i32`

This is a released experimental exp-21 fixture. It does not claim beta
maturity or widen `f32`, unsigned integers, narrower integer widths,
char/bytes/decimal, numeric casts, implicit promotion, mixed
`i32`/`i64`/`f64` arithmetic, i64 collections, i64 enum payloads, i64 struct
fields, parsing, random `i64`, broader math APIs, manifest schema, or stable
ABI/layout.

Current exp-22 fixture support:

- `examples/supported/numeric-widening-conversions.slo`
- `examples/formatter/numeric-widening-conversions.slo`
- `std.num.i32_to_i64 : (i32) -> i64`
- `std.num.i32_to_f64 : (i32) -> f64`
- `std.num.i64_to_f64 : (i64) -> f64`
- converted values feeding same-type arithmetic and comparison
- top-level tests and `main` returning `i32`

This is a released experimental alpha exp-22 fixture. It does not claim beta
maturity or add implicit promotion, mixed numeric operators, narrowing or
checked conversions, cast syntax, `f32`, unsigned or narrower integer
families, numeric parse/format APIs, stable ABI/layout, manifest schema, or
standard-library breadth.

Current exp-23 fixture support:

- `examples/supported/checked-i64-to-i32-conversion.slo`
- `examples/formatter/checked-i64-to-i32-conversion.slo`
- `std.num.i64_to_i32_result : (i64) -> (result i32 i32)`
- `ok` results for signed `i32` range values
- `err 1` results for out-of-range values, without range-failure traps
- existing `std.result.*` observers and unwraps
- top-level tests and `main` returning `i32`

This is a released experimental alpha exp-23 fixture. It does not claim beta
maturity or add `f64` narrowing, checked cast generics, mixed numeric
operators, `std.num.cast`, unsigned or narrower integer families, numeric
parse/format APIs, stable ABI/layout, manifest schema, or standard-library
breadth.

Current exp-25 fixture support:

- `examples/supported/string-parse-i64-result.slo`
- `examples/formatter/string-parse-i64-result.slo`
- `std.string.parse_i64_result : (string) -> (result i64 i32)`
- complete non-empty ASCII signed decimal `i64` parsing with optional leading
  `-`
- success as `ok value` and parse/range failure as `err 1`
- existing result observation/extraction helpers over `(result i64 i32)`
- top-level tests and `main` returning `i32`

This is a released experimental alpha exp-25 fixture. It does not claim beta
maturity or add `f64` parse, generic parse, leading `+`, whitespace trimming,
underscores, base/radix prefixes, locale-aware parsing, Unicode digit parsing,
rich parse errors, stable ABI/layout/ownership, manifest schema, or
standard-library breadth.

Current exp-26 fixture support:

- `examples/supported/f64-to-string.slo`
- `examples/formatter/f64-to-string.slo`
- `std.num.f64_to_string : (f64) -> string`
- finite decimal ASCII text for promoted finite `f64` values
- existing string equality, `std.string.len`, and `std.io.print_string`
- top-level tests and `main` returning `i32`

This is a released experimental alpha exp-26 fixture. It does not claim beta
maturity or add `f32`, `f64` parse, generic format/display/interpolation,
locale/base/radix/grouping/padding/precision controls, stable NaN/infinity
text, implicit conversion, stable ABI/layout/ownership, manifest schema, or
standard-library breadth.

Current exp-27 fixture support:

- `examples/supported/f64-to-i32-result.slo`
- `examples/formatter/f64-to-i32-result.slo`
- `std.num.f64_to_i32_result : (f64) -> (result i32 i32)`
- `ok value` only for finite, exactly integral `f64` inputs inside the signed
  `i32` range
- `err 1` for non-finite, fractional, or out-of-range input
- existing result observation/extraction helpers over `(result i32 i32)`
- top-level tests and `main` returning `i32`

This is a released experimental alpha exp-27 fixture. It does not claim beta
maturity or add unchecked `f64` to `i32`, casts or cast syntax, generic
`cast_checked`, `f32`, unsigned or narrower integer families, `f64` parse,
mixed numeric arithmetic, numeric containers, stable ABI/layout/ownership,
manifest schema, or standard-library breadth.

Current exp-28 fixture support:

- `examples/supported/string-parse-f64-result.slo`
- `examples/formatter/string-parse-f64-result.slo`
- `std.string.parse_f64_result : (string) -> (result f64 i32)`
- complete finite ASCII decimal `f64` parsing
- `ok value` for `12.5` and `-0.25`
- `err 1` for ordinary parse failure, non-finite text, trailing or leading
  unsupported characters, or out-of-domain input
- existing result observation/extraction helpers over `(result f64 i32)`
- top-level tests and `main` returning `i32`

This is a released experimental alpha exp-28 fixture. It does not claim beta
maturity or add generic parse, bool/string/bytes parse, locale parsing,
Unicode digit parsing, underscores, rich parse errors, stable helper
ABI/layout/ownership, result genericity, f64 containers, mixed numeric
arithmetic, manifest schema, or standard-library breadth.

Current exp-29 fixture support:

- `examples/supported/numeric-struct-fields.slo`
- `examples/formatter/numeric-struct-fields.slo`
- direct immutable struct fields whose field types are exactly `i64` or `f64`
- constructors with `i64` and finite `f64` field initializers
- immutable struct local/parameter/return/call flow
- field access returning `i64` or `f64`
- existing same-type numeric arithmetic/comparison after field access
- existing numeric print/format helpers after field access
- top-level tests and `main` returning `i32`

This is a released experimental alpha exp-29 fixture. It does not claim beta
maturity or add struct field mutation, nested structs,
arrays/vectors/options/results as fields, enum payload widening, numeric
containers, `f32`, unsigned or narrower integer families, mixed numeric
arithmetic, implicit conversions, new parse/format APIs, generic structs,
methods, traits, stable ABI/layout/ownership, manifest schema, FFI layout
claims, or standard-library breadth.

Current exp-30 source-layout support:

- `std/README.md`
- `std/cli.slo`
- `std/io.slo`
- `std/string.slo`
- `std/num.slo`
- `std/result.slo`
- `std/math.slo`
- `examples/formatter/std-source-layout-alpha.slo`
- flat current module names inside `std/*.slo` while repo-root `std`
  import/search remains deferred
- source-authored `std/math.slo` helpers: `abs_i32`, `min_i32`, `max_i32`,
  `clamp_i32`, `square_i32`, and `square_f64`

This is a released experimental alpha exp-30 source-layout fixture. It does
not claim beta maturity or add automatic standard-library imports, replacement
of compiler-known `std.*` calls, new compiler-known `std.*` operation names,
stable standard-library APIs, manifest schema changes, broad math, generics,
traits, overloads, module/package registry behavior, or stable ABI/layout.

Current exp-31 fixture support:

- `examples/supported/f64-to-i64-result.slo`
- `examples/formatter/f64-to-i64-result.slo`
- `std.num.f64_to_i64_result : (f64) -> (result i64 i32)`
- `ok value` only for finite, exactly integral `f64` inputs inside the signed
  `i64` range
- `err 1` for non-finite, fractional, or out-of-range input
- formatter-stable conservative out-of-range fixture value
  `9223372036854776000.0`
- existing result observation/extraction helpers over `(result i64 i32)`
- `std.num.i64_to_string` over a successful `i64` payload
- top-level tests and `main` returning `i32`

This is a released experimental alpha exp-31 fixture. It does not claim beta
maturity or add unchecked casts, unchecked `f64` to `i64`, cast syntax,
generic `cast_checked`, `f32`, unsigned or narrower integer families, mixed
numeric arithmetic, broad math, numeric containers, stable ABI/layout/
ownership, manifest schema changes, or standard-library breadth. Detailed
edge behavior around the `f64`/`i64` limits is implementation-owned Glagol
test coverage.

Current exp-32 source-helper support:

- `std/math.slo`
- retained exp-30 helpers: `abs_i32`, `min_i32`, `max_i32`, `clamp_i32`,
  `square_i32`, and `square_f64`
- added `i64` helpers: `abs_i64`, `min_i64`, `max_i64`, `clamp_i64`, and
  `square_i64`
- added finite `f64` helpers: `abs_f64`, `min_f64`, `max_f64`, and
  `clamp_f64`
- ordinary source functions using existing same-type arithmetic/comparison,
  `if`, literals, calls, and explicit signatures

This is a released experimental alpha exp-32 source fixture. It does not
claim beta maturity or add automatic standard-library imports, compiler-loaded
`std/` source, new compiler-known `std.*` operation names, broad math,
trigonometry, `sqrt`, `pow`, `f32`, unsigned or narrower integer families,
generic math, overloads, traits, mixed numeric arithmetic, numeric containers,
stable ABI/layout/ownership, manifest schema changes, or standard-library
breadth.

Current exp-33 source-helper support:

- `std/result.slo`
- retained i32 helpers: `is_ok_i32`, `is_err_i32`, `unwrap_ok_i32`, and
  `unwrap_err_i32`
- completed concrete err wrappers: `is_err_i64`, `unwrap_err_i64`,
  `is_err_string`, `unwrap_err_string`, `is_err_f64`, and `unwrap_err_f64`
- concrete fallback helpers: `unwrap_or_i32`, `unwrap_or_i64`,
  `unwrap_or_string`, and `unwrap_or_f64`
- ordinary source functions over existing `std.result.is_ok`,
  `std.result.is_err`, `std.result.unwrap_ok`, `std.result.unwrap_err`, `if`,
  `match`, parameters, and explicit signatures

This is a released experimental alpha exp-33 source fixture. It does not
claim beta maturity or add automatic standard-library imports, compiler-loaded
`std/` source, new compiler-known `std.*` operation names, generic
`std.result.map`, generic `std.result.unwrap_or`, `std.result.and_then`,
option helper names, new result payload families, stable ABI/layout/
ownership, manifest schema changes, or standard-library breadth.

Current exp-34 fixture support:

- `examples/supported/string-parse-bool-result.slo`
- `examples/formatter/string-parse-bool-result.slo`
- `std.string.parse_bool_result : (string) -> (result bool i32)`
- exact complete ASCII lowercase `true` and `false` parsing
- `ok true` for `true`
- `ok false` for `false`
- `err 1` for empty input, uppercase or mixed-case text, leading or trailing
  whitespace, numeric text, and any other text
- existing result observation/extraction helpers over the returned
  `(result bool i32)` value
- top-level tests and `main` returning `i32`

This is a released experimental alpha exp-34 fixture. It does not claim beta
maturity or add generic parse APIs, trap-based parse, bool parsing beyond
exact lowercase `true`/`false`, string/bytes parse, whitespace trimming,
case-insensitive parsing, locale/Unicode parsing, numeric boolean parsing,
rich parse errors, source-authored `std/result.slo` bool wrappers, stable
helper ABI/layout/ownership, manifest schema changes, or standard-library
breadth.

Current exp-35 source-helper support:

- `std/result.slo`
- retained exp-33 concrete result source helpers
- added `(result bool i32)` helpers: `is_ok_bool`, `is_err_bool`,
  `unwrap_ok_bool`, `unwrap_err_bool`, and `unwrap_or_bool`
- ordinary source functions over existing compiler-supported
  `std.result.is_ok`, `std.result.is_err`, `std.result.unwrap_ok`,
  `std.result.unwrap_err`, `if`, parameters, and explicit signatures
- alignment with exp-34 compiler-supported bool parse result fixture flow

This is a released experimental alpha exp-35 source fixture. It does not
claim beta maturity or add automatic standard-library imports,
compiler-loaded `std/` source, new compiler-known `std.*` operation names,
source-authored generic result helpers, generic `std.result.map`, generic
`std.result.unwrap_or`, `std.result.and_then`, option helper names,
source constructors for `(result bool i32)`, general source `match` over
`(result bool i32)` beyond compiler-supported fixture flow, stable
ABI/layout/ownership, manifest schema changes, or standard-library breadth.

Current exp-74/exp-109 source-helper support:

- `std/result.slo`
- retained exp-33 and exp-35 concrete result source helpers
- concrete source constructors: `ok_i32`, `err_i32`, `ok_i64`, `err_i64`,
  `ok_string`, `err_string`, `ok_f64`, `err_f64`, `ok_bool`, and `err_bool`
- concrete bridge helpers: `ok_or_none_i32`, `ok_or_none_i64`,
  `ok_or_none_string`, `ok_or_none_f64`, and `ok_or_none_bool`
- ordinary source functions over existing compiler-supported `ok`, `err`,
  `std.result.is_ok`, `std.result.unwrap_ok`, `some`, `none`, `if`,
  `match`, parameters, and explicit signatures

This is the released experimental alpha result helper family through exp-109.
It does not claim beta maturity or add automatic standard-library imports,
compiler-loaded `std/` source, new compiler-known `std.*` operation names,
generic result helpers, broader `map`/`and_then`/`transpose`/`flatten`
packages, new payload families, stable ABI/layout/ownership, manifest schema
changes, or standard-library breadth.

Current exp-36/exp-75/exp-95/exp-100/exp-102/exp-109 source-helper support:

- `std/option.slo`
- concrete `(option i32)` helpers: `some_i32`, `none_i32`, `is_some_i32`,
  `is_none_i32`, `unwrap_some_i32`, `unwrap_or_i32`, and `some_or_err_i32`
- concrete `(option i64)` helpers: `some_i64`, `none_i64`, `is_some_i64`,
  `is_none_i64`, `unwrap_some_i64`, `unwrap_or_i64`, and `some_or_err_i64`
- concrete `(option f64)` helpers: `some_f64`, `none_f64`, `is_some_f64`,
  `is_none_f64`, `unwrap_some_f64`, `unwrap_or_f64`, and `some_or_err_f64`
- concrete `(option bool)` helpers: `some_bool`, `none_bool`, `is_some_bool`,
  `is_none_bool`, `unwrap_some_bool`, `unwrap_or_bool`, and
  `some_or_err_bool`
- concrete `(option string)` helpers: `some_string`, `none_string`,
  `is_some_string`, `is_none_string`, `unwrap_some_string`,
  `unwrap_or_string`, and `some_or_err_string`
- ordinary source functions over existing compiler-supported `is_some`,
  `is_none`, `unwrap_some`, `ok`, `err`, `if`, parameters, and explicit
  signatures
- flat `std/*.slo` facade organization, with any future `std.slo`
  aggregator/reexport layer deferred until import/search semantics exist

This is the released experimental alpha option helper family through exp-109.
It does not
claim beta maturity or add automatic standard-library imports, repo-root
`std/` search, compiler-loaded `std/` source, new compiler-known `std.*`
operation names, generic option helpers, option payload families beyond
`(option i32)`, `(option i64)`, `(option f64)`, `(option bool)`, and
`(option string)`, stable ABI/layout/ownership, manifest schema changes, or
standard-library breadth.

Current exp-111 stdlib/source support:

- `std/io.slo` retains the zero-returning and value-returning print wrappers
  and now also adds `read_stdin_result`, `read_stdin_option`,
  `read_stdin_or`, `read_stdin_i32_result`, `read_stdin_i32_option`,
  `read_stdin_i32_or_zero`, `read_stdin_i32_or`, `read_stdin_i64_result`,
  `read_stdin_i64_option`, `read_stdin_i64_or_zero`, `read_stdin_i64_or`,
  `read_stdin_f64_result`, `read_stdin_f64_option`,
  `read_stdin_f64_or_zero`, `read_stdin_f64_or`, `read_stdin_bool_result`,
  `read_stdin_bool_option`, `read_stdin_bool_or_false`, and
  `read_stdin_bool_or`
- the matching explicit import fixture `examples/projects/std-import-io/`
  now imports the expanded helper list and keeps stdin assertions structural
  so the runner does not need to provide a specific stdin payload
- all new helpers are ordinary source wrappers over the promoted
  `std.io.read_stdin_result`, `std.string.parse_*_result`, and exp-109
  `std.result.ok_or_none_*`

Current exp-110 stdlib/source support:

- `std/string.slo` retains `len`, `concat`, the concrete `parse_*_result`
  wrappers, the zero/custom-fallback helpers, and now also adds
  `parse_i32_option`, `parse_i64_option`, `parse_f64_option`, and
  `parse_bool_option`
- `std/env.slo` retains `get`, `get_result`, `has`, `get_or`, the typed
  `*_result` and fallback helpers, and now also adds `get_option`,
  `get_i32_option`, `get_i64_option`, `get_f64_option`, and
  `get_bool_option`
- `std/fs.slo` retains text read/write helpers, the typed `*_result` and
  fallback helpers, and now also adds `read_text_option`,
  `read_i32_option`, `read_i64_option`, `read_f64_option`, and
  `read_bool_option`
- `std/process.slo` retains `argc`, `arg`, `arg_result`, `has_arg`,
  `arg_or`, `arg_or_empty`, the typed `*_result` and fallback helpers, and
  now also adds `arg_option`, `arg_i32_option`, `arg_i64_option`,
  `arg_f64_option`, and `arg_bool_option`
- `std/cli.slo` retains `arg_text_result`, the typed `*_result` and fallback
  helpers, and now also adds `arg_text_option`, `arg_i32_option`,
  `arg_i64_option`, `arg_f64_option`, and `arg_bool_option`
- all new helpers are ordinary source wrappers over existing concrete result
  helpers through exp-109 `std.result.ok_or_none_*`
- the matching explicit import fixtures
  `examples/projects/std-import-string/`,
  `examples/projects/std-import-env/`,
  `examples/projects/std-import-fs/`,
  `examples/projects/std-import-process/`, and
  `examples/projects/std-import-cli/`
  now import the expanded helper lists and keep deterministic option/result
  and fallback coverage

This is the current released exp-111 stdlib/source contract summary, with the
immediately previous exp-110 source package still listed above. It does not
claim beta maturity or add compiler-known std names, generics, new runtime
calls beyond the already promoted stdin-result lane, line/binary/async stdin
APIs, vec work, stable ABI/layout/ownership, or optimizer guarantees.

Current exp-125 Slovo-side target:

- `std/result.slo` stages concrete `(result u32 i32)` and `(result u64 i32)`
  constructor, observer, unwrap, fallback, and option-bridge helpers
- `std/option.slo` stages concrete `(option u32)` and `(option u64)`
  constructor, observer, unwrap, fallback, and result-bridge helpers
- `std/string.slo` stages `parse_u32_*` and `parse_u64_*` result/option/
  fallback helper lanes
- `std/num.slo` stages `u32_to_string` and `u64_to_string`
- `std/io.slo`, `std/env.slo`, `std/fs.slo`, `std/process.slo`, and
  `std/cli.slo` stage matching `u32`/`u64` helper parity over the concrete
  family pattern already used for `i32`, `i64`, `f64`, `bool`, and `string`
- the matching Slovo fixtures are `u32-numeric-primitive.slo`,
  `u64-numeric-primitive.slo`, `unsigned-integer-to-string.slo`,
  `string-parse-u32-result.slo`, `string-parse-u64-result.slo`, and the
  widened `examples/projects/std-import-*` module fixtures

This is a current Slovo-side contract target only. It does not claim beta
maturity, released compiler support, implicit promotion, mixed
signed/unsigned arithmetic, broader cast families, unsigned widths beyond
`u32`/`u64`, or stable ABI/layout/ownership.

Current exp-37 source-facade support:

- `std/time.slo`
- narrow time wrappers: `monotonic_ms` and `sleep_ms_zero`
- ordinary source functions over existing compiler-supported
  `std.time.monotonic_ms`, `std.time.sleep_ms`, parameters, sequential body
  forms, and explicit signatures
- flat `std/*.slo` facade organization, with any future `std.slo`
  aggregator/reexport layer deferred until import/search semantics exist

This is a released experimental alpha exp-37 source fixture. It does not
claim beta maturity or add automatic standard-library imports, repo-root
`std/` search, compiler-loaded `std/` source, new compiler-known `std.*`
operation names, wall-clock/calendar/timezone APIs, high-resolution timers,
async timers, cancellation, scheduling guarantees, stable ABI/layout/ownership,
manifest schema changes, or standard-library breadth.

Current exp-38 source-facade support:

- `std/random.slo`
- `std/env.slo`
- `std/fs.slo`
- narrow host/runtime wrappers for `std.random.i32`, `std.env.get`,
  `std.env.get_result`, `std.fs.read_text`, `std.fs.read_text_result`,
  `std.fs.write_text`, and `std.fs.write_text_result`
- flat `std/*.slo` facade organization, with any future `std.slo`
  aggregator/reexport layer deferred until import/search semantics exist

This is a released experimental alpha exp-38 source fixture. It does not
claim beta maturity or add automatic standard-library imports, repo-root
`std/` search, compiler-loaded `std/` source, new compiler-known `std.*`
operation names, random seed/range/bytes/float/UUID/crypto APIs, environment
mutation/enumeration, rich host error ADTs, binary/directory/streaming/async
filesystem APIs, stable ABI/layout/ownership, manifest schema changes, or
standard-library breadth.

Current exp-39 source-helper support:

- `std/math.slo`
- retained exp-32 helpers: `abs`, `min`, `max`, `clamp`, and `square` for
  the currently staged `i32`, `i64`, and finite `f64` families
- added helpers for each family: `neg`, `cube`, `is_zero`, `is_positive`,
  `is_negative`, and inclusive `in_range`
- ordinary source functions using existing same-type arithmetic/comparison,
  `if`, literals, calls, and explicit signatures
- matching Glagol benchmark scaffold gates for local `math-loop` timing
  comparisons only, with no performance threshold in the language contract

This is a released experimental alpha exp-39 source fixture. It does not
claim beta maturity or add automatic standard-library imports, repo-root
`std/` search, compiler-loaded `std/` source, new compiler-known `std.*`
operation names, trigonometry, `sqrt`, `pow`, modulo, bit operations,
generic math, overloads, traits, mixed numeric arithmetic, optimizer
guarantees, benchmark thresholds, stable ABI/layout/ownership, manifest schema
changes, or standard-library breadth.

Current exp-40 governance/tooling support:

- project licensing recorded as `MIT OR Apache-2.0`
- release naming criteria documented in `.llm/ALPHA_BETA_RELEASE_CRITERIA.md`
- Glagol benchmark-suite gates aligned for `math-loop`, `branch-loop`,
  `parse-loop`, `array-index-loop`, `string-eq-loop`,
  `array-struct-field-loop`, and `enum-struct-payload-loop`
- Slovo, C, Rust, Python, and Clojure benchmark source slots, with local-only
  timing comparisons and no release threshold; Common Lisp/SBCL is also part
  of the current paired benchmark publication surface

This is a released experimental alpha exp-40 governance/tooling fixture. It
does not claim beta maturity or add source syntax, type forms,
standard-library APIs, optimizer guarantees, benchmark thresholds,
cross-machine performance claims, stable ABI/layout/ownership, package
registry behavior, or language-surface changes.

Current exp-41 governance/tooling support:

- Glagol benchmark-suite gates include Common Lisp/SBCL beside Clojure as a
  second Lisp-family comparison target
- benchmark timing is explicitly cold-process local-machine evidence only
- Clojure timings include JVM and Clojure startup; Common Lisp timings include
  SBCL script startup
- the current published benchmark-suite kernel inventory is
  `math-loop`, `branch-loop`, `parse-loop`, `array-index-loop`,
  `string-eq-loop`, `array-struct-field-loop`, and
  `enum-struct-payload-loop`

This is a released experimental alpha exp-41 governance/tooling fixture. It
does not claim beta maturity or add source syntax, type forms,
standard-library APIs, optimizer guarantees, benchmark thresholds,
cross-machine performance claims, stable ABI/layout/ownership, package
registry behavior, or language-surface changes.

Current exp-42 governance/tooling support:

- Glagol benchmark-suite gates separate `cold-process` and `hot-loop` timing
  modes
- hot-loop mode uses a larger runtime-supplied loop count and reports total
  time plus normalized median time for the base loop count
- the paired benchmark-suite kernel inventory now covers arithmetic, branching,
  parsing, checked fixed-array indexing, exact string equality, direct
  fixed-array struct-field access, and unary enum payload matching over
  non-recursive struct payloads
- Slovo language surface remains unchanged; no high-resolution timing API is
  promoted

This is a released experimental alpha exp-42 governance/tooling fixture. It
does not claim beta maturity or add source syntax, type forms,
standard-library APIs, high-resolution timing APIs, optimizer guarantees,
benchmark thresholds, cross-machine performance claims, stable
ABI/layout/ownership, package registry behavior, or language-surface changes.

Current exp-43 documentation/tooling support:

- `docs/SLOVO_WHITEPAPER.md` records the current language state, Lisp-family
  comparison, local benchmark evidence, and path to `1.0.0-beta`
- generated PDF artifacts publish the whitepaper and language manifest
- `.llm/skills/slovo-beta-language-design/SKILL.md` records the
  manifest-first beta language-design workflow

This is a released experimental alpha exp-43 documentation/tooling fixture.
It does not claim beta maturity or add source syntax, type forms,
standard-library APIs, optimizer guarantees, benchmark thresholds,
cross-machine performance claims, stable ABI/layout/ownership, package
registry behavior, or language-surface changes.

Current exp-44 language/tooling support:

- `std/math.slo` carries its own export list for helper imports
- `examples/projects/std-import-math/` imports `(import std.math (...))`
  without a local copied `math.slo`
- Glagol resolves explicit project-mode `std.math` imports to the repo-root
  standard-library source file

This is a released experimental alpha exp-44 source-search fixture. It does
not claim beta maturity or add automatic standard-library imports, broad
standard-library APIs, package registry behavior, workspace/package std
imports, optimizer guarantees, stable ABI/layout/ownership, or a `std.slo`
aggregator.

Current exp-45 language/tooling support:

- `std/result.slo` and `std/option.slo` carry their own export lists
- `examples/projects/std-import-result/` imports `(import std.result (...))`
  without a local copied `result.slo`
- `examples/projects/std-import-option/` imports `(import std.option (...))`
  without a local copied `option.slo`
- Glagol resolves these explicit project-mode imports to the repo-root
  standard-library source files

This is a released experimental alpha exp-45 source-search fixture. It does
not claim beta maturity or add automatic standard-library imports, generic
result or option helpers, broad standard-library APIs, package registry
behavior, workspace/package std imports, optimizer guarantees, stable
ABI/layout/ownership, or a `std.slo` aggregator.

Current exp-46 language/tooling support:

- `examples/workspaces/std-import-option/` imports `(import std.option (...))`
  from a workspace package without a local copied `option.slo`
- Glagol resolves explicit workspace-package `std.<module>` imports to the
  repo-root standard-library source files

This is a released experimental alpha exp-46 source-search fixture. It does
not claim beta maturity or add automatic standard-library imports, workspace
dependency syntax for std, package registry behavior, installed toolchain
stdlib paths, generic option helpers, broad standard-library APIs, optimizer
guarantees, stable ABI/layout/ownership, or a `std.slo` aggregator.

Current exp-47 language/tooling support:

- `std/time.slo`, `std/random.slo`, `std/env.slo`, and `std/fs.slo` carry
  their own export lists for helper imports
- `examples/projects/std-import-time/` imports `(import std.time (...))`
  without a local copied `time.slo`
- `examples/projects/std-import-random/` imports `(import std.random (...))`
  without a local copied `random.slo`
- `examples/projects/std-import-env/` imports `(import std.env (...))`
  without a local copied `env.slo`
- `examples/projects/std-import-fs/` imports `(import std.fs (...))`
  without a local copied `fs.slo`

This is a released experimental alpha exp-47 source-search fixture. It does
not claim beta maturity or add automatic standard-library imports, installed
toolchain stdlib paths, broad host APIs, optimizer guarantees, stable
ABI/layout/ownership, package registry behavior, or a `std.slo` aggregator.

Current exp-48 language/tooling support:

- `std/string.slo` and `std/num.slo` carry their own export lists for helper
  imports
- `examples/projects/std-import-string/` imports `(import std.string (...))`
  without a local copied `string.slo`
- `examples/projects/std-import-num/` imports `(import std.num (...))`
  without a local copied `num.slo`

This is a released experimental alpha exp-48 source-search fixture. It does
not claim beta maturity or add automatic standard-library imports, installed
toolchain stdlib paths, generic parse/format APIs, broad numeric casts,
optimizer guarantees, stable ABI/layout/ownership, package registry behavior,
or a `std.slo` aggregator.

Current exp-49 language/tooling support:

- `std/io.slo` carries its own export list for helper imports
- `examples/projects/std-import-io/` imports `(import std.io (...))`
  without a local copied `io.slo`

This is a released experimental alpha exp-49 source-search fixture. It does
not claim beta maturity or add automatic standard-library imports, installed
toolchain stdlib paths, broad IO APIs, formatted output APIs, optimizer
guarantees, stable ABI/layout/ownership, package registry behavior, or a
`std.slo` aggregator.

Current exp-50 language/tooling support:

- explicit standard-source imports may discover staged `std/*.slo` modules
  from installed `share/slovo/std` toolchain layouts
- no new `std/*.slo` module, helper, or compiler-known runtime name is added

This is a released experimental alpha exp-50 discovery fixture. It does not
claim beta maturity or add automatic standard-library imports, package
registry behavior, lockfiles, package std dependencies, stable install layout
guarantees, optimizer guarantees, stable ABI/layout/ownership, or a
`std.slo` aggregator.

Current exp-51 language/tooling support:

- `SLOVO_STD_PATH` may name an ordered OS path list of standard-library roots
- the first root containing the requested module file wins

This is a released experimental alpha exp-51 discovery fixture. It does not
claim beta maturity or add automatic standard-library imports, package
registry behavior, lockfiles, semantic version solving, stable package
manager behavior, optimizer guarantees, stable ABI/layout/ownership, or a
`std.slo` aggregator.

Current exp-52 language/tooling support:

- `std/process.slo` carries its own export list for helper imports
- `examples/projects/std-import-process/` imports `(import std.process (...))`
  without a local copied `process.slo`

This is a released experimental alpha exp-52 source-search fixture. It does
not claim beta maturity or add automatic standard-library imports, package
registry behavior, process spawning, exit/status control, current-directory
APIs, signal handling, optimizer guarantees, stable ABI/layout/ownership, or a
`std.slo` aggregator.

Current exp-53 language/tooling support:

- `std/cli.slo` carries its own export list for helper imports
- `std/cli.slo` imports `std.process` and `std.string` as ordinary standard
  source modules
- `examples/projects/std-import-cli/` imports `(import std.cli (...))`
  without a local copied `cli.slo`

This is a released experimental alpha exp-53 source-search fixture. It does
not claim beta maturity or add automatic standard-library imports, package
registry behavior, shell parsing, option/flag parsing, subcommands,
environment-backed configuration, optimizer guarantees, stable
ABI/layout/ownership, or a `std.slo` aggregator.

Current exp-54 language/tooling support:

- `std/cli.slo` adds `arg_i64_result` and `arg_i64_or_zero`
- `std/cli.slo` adds `arg_f64_result`, `arg_f64_or_zero`, `arg_bool_result`,
  and `arg_bool_or_false`
- `examples/projects/std-import-cli/` imports the expanded helper list and
  keeps deterministic tests on the currently source-supported result families

This is a released experimental alpha exp-54 source-facade fixture. It does
not claim beta maturity or add automatic standard-library imports, package
registry behavior, shell parsing, option/flag parsing, subcommands,
environment-backed configuration, optimizer guarantees, stable
ABI/layout/ownership, or a `std.slo` aggregator.

Current exp-101 stdlib/source support:

- `std/vec_string.slo` now stages the concrete `(vec string)` facade through
  the exp-99 baseline plus the exp-101 option-query and transform package
- the baseline direct wrappers remain `empty`, `append`, `len`, and `at`
- the baseline builder helpers remain `singleton`, `append2`, `append3`,
  `pair`, and `triple`
- the baseline query helpers remain `is_empty`, `index_or`, `first_or`, and
  `last_or`
- the new option-query helpers are `index_option`, `first_option`,
  `last_option`, `index_of_option`, and `last_index_of_option`
- the new transform helpers are `concat`, `take`, `drop`, `reverse`, and
  `subvec`
- the simple real-program helpers remain `contains` and `count_of`
- the helper lane stays source-authored, recursive, and immutable over only
  `std.vec.string.empty`, `std.vec.string.append`, `std.vec.string.len`, and
  `std.vec.string.index`
- the explicit project fixture `examples/projects/std-import-vec_string/` now
  exercises deterministic baseline, option-query, transform, subvec, and
  real-program coverage

This is the current released exp-101 stdlib/source contract. It does not
claim beta maturity or add compiler-known std names, generics, vec edit
helpers, prefix/suffix helpers, nested vecs, mutating/capacity APIs, stable
ABI/layout/ownership, or optimizer guarantees.

Current exp-108 stdlib/source support:

- `std/vec_string.slo` retains the exp-99 baseline and exp-101 option-query
  plus transform surfaces, exp-107 edit helpers, and now also ships
  `starts_with`, `without_prefix`, `ends_with`, and `without_suffix`
- `std/vec_f64.slo` retains the exp-103 baseline, exp-105 transform, and
  exp-106 option-query surfaces, exp-107 edit helpers, and now also ships
  the same four prefix/suffix helpers
- `std/vec_bool.slo` retains the exp-104 baseline, exp-105 transform, and
  exp-106 option-query surfaces, exp-107 edit helpers, and now also ships
  the same four prefix/suffix helpers
- all three helper lanes stay source-authored, recursive, and immutable over
  only their existing four runtime calls per family plus already promoted
  concrete option families where earlier helpers need them
- the explicit project fixtures
  `examples/projects/std-import-vec_string/`,
  `examples/projects/std-import-vec_f64/`, and
  `examples/projects/std-import-vec_bool/` now freeze deterministic direct,
  builder, query, option-query, prefix/suffix, transform, subvec, edit, and
  real-program coverage

This is the current released exp-108 stdlib/source contract. It does not
claim beta maturity or add compiler-known std names, generics, sorting,
mapping, filtering, nested vecs, mutating/capacity APIs, stable
ABI/layout/ownership, or optimizer guarantees.

Current exp-93 stdlib/source support:

- `std/vec_i32.slo` retains the exp-76 direct, builder, query, option-query,
  simple real-program, transform, generated constructor, range, replace,
  remove, insert, subvec, remove-range, replace-range, insert-range,
  starts-with, ends-with, without-suffix, and without-prefix helper surface
- `std/vec_i32.slo` adds exactly one new public helper, `count_of`
- `count_of ((values (vec i32)) (target i32)) -> i32` returns the number of
  elements in `values` equal to `target`
- `count_of (empty) target` returns `0`
- if no element equals `target`, `count_of` returns `0`
- repeated matches are counted exactly
- the helper leaves both source vectors unchanged
- the implementation is an ordinary source helper over existing `len`, `at`,
  equality, and `while`
- `examples/projects/std-import-vec_i32/` imports the expanded helper list
  and keeps deterministic empty, repeated-match, single-match, no-match, and
  unchanged-source tests

This is the current released exp-93 stdlib/source contract. It does not
claim beta maturity or add automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, generic collections, slice/view types, vector
payload widening, broader copied subvector/range-edit helper families beyond
`insert_range`, `replace_range`, `remove_range`, and `subvec`, public
insert/remove/edit families beyond `insert_range`, `replace_range`,
`remove_range`, `subvec`, `insert_at`, `replace_at`, and `remove_at`,
mutating vec APIs, capacity/reserve/shrink, sorting, mapping, filtering,
iterators, optimizer guarantees, or stable ABI/layout/ownership.

Current exp-87 stdlib/source support:

- `std/vec_i32.slo` retains the exp-76 direct, builder, query, option-query,
  simple real-program, transform, generated constructor, range, replace,
  remove, insert, subvec, and remove-range helper surface
- `std/vec_i32.slo` adds exactly one new public helper, `insert_range`
- `insert_range ((values (vec i32)) (position i32) (inserted (vec i32))) ->
  (vec i32)` inserts all of `inserted` into `values` at a valid `position`
- if `position < 0` or `position > len(values)`, `insert_range` returns
  `values` unchanged
- if `0 <= position < len(values)`, `insert_range` inserts all of `inserted`
  before the current element at `position`
- if `position == len(values)`, `insert_range` appends `inserted` at the end
- the helper preserves the order of both vectors and leaves both source
  vectors unchanged
- the result length is `len(values) + len(inserted)` for valid positions
- the implementation is an ordinary compositional source helper over existing
  `take`, `drop`, and `concat`
- `examples/projects/std-import-vec_i32/` imports the expanded helper list
  and keeps deterministic middle insertion, append-at-end insertion,
  negative-position, out-of-range-position, and unchanged-source tests

This is the current released exp-87 stdlib/source contract. It does not claim
beta maturity or add automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, generic collections, slice/view types, vector
payload widening, broader copied subvector/range-edit helper families beyond
`insert_range`, `remove_range`, and `subvec`, public insert/remove/edit
families beyond `insert_range`, `remove_range`, `subvec`, `insert_at`,
`replace_at`, and `remove_at`, mutating vec APIs, capacity/reserve/shrink,
sorting, mapping, filtering, iterators, optimizer guarantees, or stable
ABI/layout/ownership.

Current exp-86 stdlib/source support:

- `std/vec_i32.slo` retains the exp-76 direct, builder, query, option-query,
  simple real-program, transform, generated constructor, range, replace,
  remove, insert, and subvec helper surface
- `std/vec_i32.slo` adds exactly one new public helper, `remove_range`
- `remove_range ((values (vec i32)) (start i32) (end_exclusive i32)) ->
  (vec i32)` removes the half-open range `[start, end_exclusive)` from
  `values`
- if `start < 0`, `end_exclusive <= start`, or `start >= len(values)`,
  `remove_range` returns `values` unchanged
- if `end_exclusive >= len(values)`, `remove_range` removes the tail from
  `start`
- the helper preserves the order of the remaining elements and leaves the
  source vector unchanged
- the implementation is an ordinary compositional source helper over existing
  `take`, `drop`, and `concat`
- `examples/projects/std-import-vec_i32/` imports the expanded helper list
  and keeps deterministic middle-range removal, tail removal,
  `end_exclusive <= start`, out-of-range-start, negative-start, and
  unchanged-source tests

This is the current released exp-86 stdlib/source contract. It does not claim
beta maturity or add automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, generic collections, slice/view types, vector
payload widening, broader subvector/range-removal helper families beyond
`remove_range` and `subvec`, public insert/remove/edit families beyond
`remove_range`, `subvec`, `insert_at`, `replace_at`, and `remove_at`,
mutating vec APIs, capacity/reserve/shrink, sorting, mapping, filtering,
iterators, optimizer guarantees, or stable ABI/layout/ownership.

Current exp-85 stdlib/source support:

- `std/vec_i32.slo` retains the exp-76 direct, builder, query, option-query,
  simple real-program, transform, generated constructor, range, replace,
  remove, and insert helper surface
- `std/vec_i32.slo` adds exactly one new public helper, `subvec`
- `subvec ((values (vec i32)) (start i32) (end_exclusive i32)) -> (vec i32)`
  returns a copied contiguous subvector `[start, end_exclusive)`
- if `start < 0`, `end_exclusive <= start`, or `start >= len(values)`,
  `subvec` returns `(empty)`
- if `end_exclusive > len(values)`, `subvec` returns the remaining tail from
  `start`
- the helper preserves source order and leaves the source vector unchanged
- the helper is an ordinary copied vec helper, not a slice/view type
- the implementation is an ordinary compositional source helper over existing
  `take` and `drop`
- `examples/projects/std-import-vec_i32/` imports the expanded helper list
  and keeps deterministic middle-range, tail-truncation, empty-range,
  out-of-range, negative-start, and unchanged-source tests

This is the current released exp-85 stdlib/source contract. It does not claim
beta maturity or add automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, generic collections, slice/view types, vector
payload widening, broader copied subvector/window helper families beyond
`subvec`, public insert/remove/edit families beyond `subvec`, `insert_at`,
`replace_at`, and `remove_at`, mutating vec APIs, capacity/reserve/shrink,
sorting, mapping, filtering, iterators, optimizer guarantees, or stable
ABI/layout/ownership.

Current exp-84 stdlib/source support:

- `std/vec_i32.slo` retains the exp-76 direct, builder, query, option-query,
  simple real-program, transform, generated constructor, range, replace, and
  remove helper surface
- `std/vec_i32.slo` adds exactly one new public helper, `insert_at`
- `insert_at ((values (vec i32)) (position i32) (value i32)) -> (vec i32)`
  returns a new vector for valid insertions while preserving source order
- if `0 <= position < len(values)`, `insert_at` inserts `value` before the
  current element at `position`
- if `position == len(values)`, `insert_at` appends `value` at the end
- if the insertion is valid, the result length is `len(values) + 1`
- if `position < 0` or `position > len(values)`, `insert_at` returns
  `values` unchanged
- the helper does not mutate the source vector
- the implementation is an ordinary compositional source helper over existing
  `append`, `take`, `drop`, and `concat`
- `examples/projects/std-import-vec_i32/` imports the expanded helper list
  and keeps deterministic middle-insert, append-at-end, negative, and
  out-of-range insertion tests

This is the current released exp-84 stdlib/source contract. It does not claim
beta maturity or add automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, generic collections, slice types, vector payload
widening, public insert/remove/edit families beyond `insert_at`,
`replace_at`, and `remove_at`, mutating vec APIs, capacity/reserve/shrink,
sorting, mapping, filtering, iterators, optimizer guarantees, or stable
ABI/layout/ownership.

Current exp-82 stdlib/source support:

- `std/vec_i32.slo` retains the exp-76 direct, builder, query, option-query,
  simple real-program, transform, generated constructor, and range helper
  surface
- `std/vec_i32.slo` adds exactly one new public helper, `replace_at`
- `replace_at ((values (vec i32)) (position i32) (replacement i32)) ->
  (vec i32)` returns a new vector with the same length and order as `values`
  except that the in-range `position` slot becomes `replacement`
- if `position < 0` or `position >= len(values)`, `replace_at` returns
  `values` unchanged
- the helper does not mutate the source vector
- the implementation is an ordinary compositional source helper over existing
  `append`, `take`, `drop`, and `concat`
- `examples/projects/std-import-vec_i32/` imports the expanded helper list
  and keeps deterministic in-range, negative, and out-of-range replacement
  tests

This is the current released exp-82 stdlib/source contract. It does not claim
beta maturity or add automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, generic collections, slice types, vector payload
widening, public insert/remove/edit families beyond `replace_at`, mutating
vec APIs, capacity/reserve/shrink, sorting, mapping, filtering, iterators,
optimizer guarantees, or stable ABI/layout/ownership.

Current exp-81 stdlib/source support:

- `std/vec_i32.slo` retains the exp-76 direct, builder, query, option-query,
  simple real-program, transform, and generated constructor helper surface
- `std/vec_i32.slo` adds exactly one new public helper, `range`
- `range ((start i32) (end_exclusive i32)) -> (vec i32)` produces an
  ascending half-open sequence from `start` up to but excluding
  `end_exclusive`
- negative bounds are allowed, and `range` returns an empty vector when
  `end_exclusive <= start`
- generation stays private through an ordinary recursive source helper over
  existing `append` and `empty` vec facade operations
- `range_from_zero` remains public and may delegate to `range 0 count`
- `examples/projects/std-import-vec_i32/` imports the expanded helper list
  and keeps deterministic negative, empty, and positive ascending tests

This is the current released exp-81 stdlib/source contract. It does not claim
beta maturity or add automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, generic collections, slice types, vector payload
widening, descending or stepped range variants, inclusive range variants,
edit helpers, mutating vec APIs, capacity/reserve/shrink, sorting, mapping,
filtering, iterators, optimizer guarantees, or stable ABI/layout/ownership.

Current exp-80 stdlib/source support:

- `std/vec_i32.slo` retains the exp-76 direct, builder, query, option-query,
  simple real-program, and transform helper surface
- `std/vec_i32.slo` adds generated constructor helpers `repeat` and
  `range_from_zero`
- the new helpers are ordinary recursive source helpers over existing
  `append` and `empty` vec facade operations
- `repeat` returns an empty vector when `count <= 0`
- `range_from_zero` returns `0..count` with an exclusive upper bound and
  returns an empty vector when `count <= 0`
- `examples/projects/std-import-vec_i32/` imports the expanded helper list
  and keeps deterministic explicit standard-source tests

This is a released experimental alpha exp-80 stdlib/source fixture. It does
not claim beta maturity or add automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, generic collections, slice types, vector payload
widening, mutating vec APIs, capacity/reserve/shrink, sorting, mapping,
filtering, iterators, optimizer guarantees, or stable ABI/layout/ownership.

Current exp-78 stdlib/source support:

- `std/cli.slo` keeps the exp-72 helper list unchanged
- `std/cli.slo` keeps `std.process` and `std.string` as its only direct
  standard-source dependencies
- the Slovo-side contract now explicitly freezes this facade for the sibling
  Glagol local-source gate
- no source edit to `std/cli.slo` is required for this release

This is a released experimental alpha exp-78 contract-alignment fixture. It
does not claim beta maturity or add automatic standard-library imports,
compiler-loaded standard-library source, package registry behavior, shell
parsing, option/flag parsing, subcommands, environment-backed configuration,
optimizer guarantees, stable ABI/layout/ownership, or a `std.slo`
aggregator.

Current exp-55 language/tooling support:

- `examples/supported/result-f64-bool-match.slo`
- source constructors for `(result f64 i32)` and `(result bool i32)`
- source `match` with `f64` and `bool` ok payload bindings and `i32` err
  payload bindings
- `std.cli` uses this support to propagate missing argument indexes for all
  typed helper result families

This is a released experimental alpha exp-55 source-flow fixture. It does not
claim beta maturity or add generic result types, result payload families
beyond the already promoted concrete families, generic result combinators,
optimizer guarantees, or stable ABI/layout/ownership.

Current exp-60 stdlib/source support:

- `std/string.slo`
- retained `len`, `concat`, and concrete `parse_*_result` wrappers
- added `parse_i32_or_zero`, `parse_i64_or_zero`, `parse_f64_or_zero`, and
  `parse_bool_or_false`
- ordinary source `match` over existing concrete `i32`, `i64`, `f64`, and
  `bool` parse result families
- `examples/projects/std-import-string/` imports the expanded helper list and
  keeps deterministic tests on both direct parse results and fallback helpers

This is a released experimental alpha exp-60 stdlib/source fixture. It does
not claim beta maturity or add automatic standard-library imports,
compiler-loaded `std/` source, generic parse helpers, whitespace trimming,
case-insensitive bool parsing, rich parse errors, optimizer guarantees, or
stable ABI/layout/ownership.

Current exp-61 stdlib/source support:

- `std/process.slo`
- retained `argc`, `arg`, `arg_result`, and `has_arg`
- added `arg_or` and `arg_or_empty`
- ordinary source `match` over the existing `(result string i32)` process
  argument family
- `examples/projects/std-import-process/` imports the expanded helper list and
  keeps deterministic tests on both missing-index and present-index flows

This is a released experimental alpha exp-61 stdlib/source fixture. It does
not claim beta maturity or add automatic standard-library imports,
compiler-loaded `std/` source, shell parsing, option/flag parsing,
subcommands, process spawning, exit/status control, rich host errors,
optimizer guarantees, or stable ABI/layout/ownership.

Current exp-56 language/stdlib support:

- `examples/supported/integer-remainder.slo`
- `examples/formatter/integer-remainder.slo`
- `%` binary operator over same-width `i32` and `i64` operands
- formatter/checker/test-runner/LLVM support for integer signed remainder
- `std/math.slo` helpers: `rem_i32`, `is_even_i32`, `is_odd_i32`,
  `rem_i64`, `is_even_i64`, and `is_odd_i64`
- explicit `std.math` import fixture coverage for the expanded helper list

This is a released experimental alpha exp-56 numeric/stdlib fixture. It does
not claim beta maturity or add floating-point remainder, Euclidean modulo,
unsigned arithmetic, bit operations, generic math, mixed numeric arithmetic,
optimizer guarantees, or stable ABI/layout/ownership.

Current exp-57 language/stdlib support:

- `examples/supported/integer-bitwise.slo`
- `examples/formatter/integer-bitwise.slo`
- `bit_and`, `bit_or`, and `bit_xor` binary heads over same-width `i32` and
  `i64` operands
- formatter/checker/test-runner/LLVM support for integer bitwise operations
- `std/math.slo` helpers: `bit_and_i32`, `bit_or_i32`, `bit_xor_i32`,
  `bit_and_i64`, `bit_or_i64`, and `bit_xor_i64`

This is a released experimental alpha exp-57 numeric/stdlib fixture. It does
not claim beta maturity or add shifts, bit-not, unsigned arithmetic,
bit-width-specific integer families, floating-point bitwise operations,
generic math, mixed numeric arithmetic, optimizer guarantees, or stable
ABI/layout/ownership.

Current exp-123 documentation/tooling support:

- `docs/SLOVO_WHITEPAPER.md` refreshed to the current exp-121 language surface
  and exp-123 publication baseline
- benchmark methodology widened from seven kernels to nine:
  `math-loop`, `branch-loop`, `parse-loop`, `array-index-loop`,
  `string-eq-loop`, `array-struct-field-loop`, `enum-struct-payload-loop`,
  `vec-i32-index-loop`, and `vec-string-eq-loop`
- paired same-machine publication tables are widened from seven rows to nine
  in the controller-owned benchmark refresh pass
- generated PDF artifacts remain published through
  `scripts/render-doc-pdfs.sh`
- compatibility `WHITEPAPER.pdf` remains mirrored from the canonical docs PDF
- explicit release metadata keeps exp-121 as the latest language-surface slice
  while exp-123 is the current publication baseline

This is a released experimental alpha exp-123 documentation/tooling fixture.
It does not claim beta maturity or add source syntax, type forms,
standard-library APIs, optimizer guarantees, benchmark thresholds,
cross-machine performance claims, stable ABI/layout/ownership, package
registry behavior, or language-surface changes.

Current exp-58 language support:

- `examples/supported/boolean-logic.slo`
- `examples/formatter/boolean-logic.slo`
- `(and left right)` and `(or left right)` as short-circuiting boolean forms
- `(not value)` as a boolean negation form
- lowering through existing `if`, so no new LLVM primitive is required

This is a released experimental alpha exp-58 boolean logic fixture. It does
not claim beta maturity or add truthiness, variadic boolean operators,
pattern guards, macro expansion, optimizer guarantees, or stable
ABI/layout/ownership.

Current exp-24 fixture support:

- `examples/supported/integer-to-string.slo`
- `examples/formatter/integer-to-string.slo`
- `std.num.i32_to_string : (i32) -> string`
- `std.num.i64_to_string : (i64) -> string`
- decimal signed ASCII strings with `-` only for negative values and no
  leading `+`
- existing string equality, `std.string.len`, and `std.io.print_string`
- top-level tests and `main` returning `i32`

This is a released experimental alpha exp-24 fixture. It does not claim beta
maturity or add `f64` formatting, parse APIs, locale/base/radix/grouping or
padding controls, generic format/display traits, implicit conversions, stable
ABI/layout and ownership, manifest schema, or standard-library breadth.

Current exp-5 fixture support:

- `examples/workspaces/exp-5-local/`
- one workspace manifest with explicit local members
- two package manifests with package name/version metadata
- one local path dependency
- one package-qualified import
- deterministic local package graph recording in artifact manifests

These are current compiler-supported exp-5 fixtures.

Current compiler-supported exp-6 fixture:

- `examples/ffi/exp-6-c-add/`
- top-level imported C function declaration for `c_add`
- `i32`-only scalar parameters and `i32` return
- lexical `(unsafe ...)` required at every imported C call site
- safe Slovo wrapper around `(unsafe (c_add 40 2))`
- fixture-scoped native C companion source, with no stable ABI/layout promise

These are current compiler-supported exp-6 fixtures after matching Slovo and
Glagol exp-6 gates.

v1 scope-freeze decisions:

- struct field/value mutation remains deferred beyond v1 unless explicitly
  promoted later
- option/result mapping, equality, printing, payloads and extraction beyond
  the explicitly promoted `(result i32 i32)`, `(result string i32)`, and
  `(result i64 i32)` concrete slices, nesting, containers, generic payloads,
  payload ADTs, and user-catchable exceptions remain deferred unless
  explicitly promoted later
- unit printing is unsupported in v1.2; `print_unit` remains deferred
- `unit` remains an internal builtin result type for supported unit-producing
  body forms; user-declared or stored `unit` values remain unsupported
- standard-runtime printing beyond v1.5 `std.io.print_i32`,
  `std.io.print_string`, and `std.io.print_bool`, exp-20
  `std.io.print_f64`, and exp-21 `std.io.print_i64` remains deferred
- `std.io.print_unit`, host IO beyond the exp-3 slice, exp-10 `*_result`
  slice, and exp-12 stdin-result slice, parsing beyond exp-13
  `std.string.parse_i32_result`, exp-25 `std.string.parse_i64_result`, and
  exp-28 `std.string.parse_f64_result`, plus exp-34 exact lowercase
  `std.string.parse_bool_result`,
  time, randomness beyond exp-11, user-visible allocation, integer formatting
  beyond exp-24, f64 formatting beyond exp-26 finite text,
  locale/base/radix/grouping/padding formatting controls, user-defined
  standard modules, overloading, generic APIs,
  Unicode length or digit semantics, and ABI/layout promises remain deferred
- lexical `unsafe` remains the only accepted unsafe boundary; v1.6 reserves
  raw unsafe operation heads for gating diagnostics, but pointer types,
  allocation, deallocation, load, store, pointer arithmetic, reinterpretation,
  unchecked indexing, raw memory execution, and FFI remain deferred
- stable ABI and stable layout promises remain deferred; v1.6 keeps memory
  direction staged toward safe values by default, future affine ownership, and
  explicit unsafe regions

v1.1 tooling release decisions:

- v1.1 is a tooling release over v1 semantics, not a source language release.
- The canonical v1.1 commands are `glagol check <file.slo>`,
  `glagol fmt <file.slo>`, `glagol test <file.slo>`, and
  `glagol build <file.slo> -o <binary>`.
- v1.1 assumes `slovo.diagnostic` version `1`,
  `slovo.artifact-manifest` version `1`, JSON diagnostics on request, artifact
  manifests on request, a hosted native build path through LLVM IR, Glagol
  runtime C, and Clang, and the stable exit-code table from
  `.llm/V1_1_TOOLCHAIN_PRODUCTIZATION.md`.
- Compatibility aliases may remain only as Glagol-side aliases that route
  through the canonical command behavior; Slovo docs teach the canonical
  commands.
- Project mode, package management, multi-file modules, write-in-place
  formatting, test filtering, build profiles, cross-compilation, stable ABI,
  object/library/header output, FFI, LSP, SARIF, and daemon protocols stay
  deferred.

v1.2 practical runtime values release decisions:

- v1.2 is a conservative source-language release over the v1.1 toolchain
  contract.
- The precise Slovo-side contract is
  `.llm/V1_2_PRACTICAL_RUNTIME_VALUES.md`.
- Runtime strings still originate only from immutable compiler-emitted source
  literals and propagation of those values; v1.2 adds no allocation, ownership,
  deallocation, stable ABI, or FFI promise.
- String concatenation stays deferred in v1.2 because it requires allocation,
  ownership, lifetime, and deallocation semantics; exp-1 later stages only the
  narrow `std.string.concat` contract.
- Runtime trap messages are stable for array bounds and option/result unwrap
  failures, are written to stderr with a trailing newline, and exit the process
  with code `1`.
- v1.2 preserves v1.1 single-file CLI/toolchain assumptions and does not add
  project mode, imports, packages, or multi-file modules.

v1.3 project mode and modules release decisions:

- v1.3 is a conservative project-mode release over the v1.2 language and
  toolchain contract.
- The precise Slovo-side contract is
  `.llm/V1_3_PROJECT_MODE_AND_MODULES.md`.
- Project mode is selected only when `glagol check`, `glagol test`, or
  `glagol build` receives a project root containing `slovo.toml` or the
  `slovo.toml` file itself.
- Passing one `.slo` file keeps the v1.2 single-file behavior unchanged.
- `slovo.toml` uses a minimal `[project]` schema with required `name`,
  optional `source_root` defaulting to `src`, and optional `entry` defaulting
  to `main`; the detailed `.llm` contract is normative for identifier,
  unknown-key, and path-boundary validation.
- v1.3 project modules are flat local `.slo` files directly under the source
  root; each file stem must match its `(module name ...)` declaration.
- Imports are explicit local imports of exported names only; there are no
  packages, dependencies, registries, version solving, workspaces, aliases,
  glob imports, qualified names, or re-exports.
- Only top-level `fn` and `struct` declarations listed in a module export list
  are importable.
- Duplicate-name, missing-import, import-cycle, ambiguous-name, and visibility
  failures are required structured diagnostics with multi-file source spans.
- `AmbiguousName` means the same unqualified name was imported from different
  modules; duplicate names within one import list remain `DuplicateName`.
- Module discovery, graph validation, test execution, diagnostics, and artifact
  manifests use deterministic ordering.

v1.4 core language expansion release decisions:

- v1.4 is a conservative source-language release over the v1.3 project-mode
  and v1.2 runtime-values contracts.
- The precise Slovo-side contract is
  `.llm/V1_4_CORE_LANGUAGE_EXPANSION.md`.
- v1.4 promotes source-level `match` only for existing `(option i32)`,
  `(option i64)`, and `(result i32 i32)` values.
- Option matches require exactly `some` and `none`; result matches require
  exactly `ok` and `err`.
- Payload bindings for `some`, `ok`, and `err` are immutable and scoped only
  to the selected arm.
- Match arm bodies may contain one or more expressions; the final expression
  is the arm value.
- The match expression type is the common arm result type. Mismatches are
  structured diagnostics.
- Existing tag observers and `unwrap_*` forms remain supported, but new
  option/result payload examples prefer `match`.
- v1.4 does not promote user-defined enums/ADTs, generic payloads, mutation,
  vectors, `i64`, general block expressions, pattern guards, wildcard/rest
  patterns, destructuring, standard-library error conventions, ownership, or
  layout/ABI promises.

v1.5 standard library alpha release decisions:

- v1.5 is a conservative standard-runtime naming release over the v1.4
  contract.
- The precise Slovo-side contract is
  `.llm/V1_5_STANDARD_LIBRARY_ALPHA.md`.
- v1.5 promotes only `std.io.print_i32`, `std.io.print_string`,
  `std.io.print_bool`, and `std.string.len`.
- These names are compiler-known source-level standard-runtime names, not user
  modules, imports, package dependencies, foreign functions, or stable C ABI
  symbols.
- `std.io.print_i32` accepts exactly one `i32`, returns builtin `unit`, and
  keeps legacy `print_i32` stdout behavior.
- `std.io.print_string` accepts exactly one `string`, returns builtin `unit`,
  and keeps legacy `print_string` stdout behavior and string-literal
  constraints.
- `std.io.print_bool` accepts exactly one `bool`, returns builtin `unit`, and
  keeps legacy `print_bool` stdout behavior.
- `std.string.len` accepts exactly one `string`, returns `i32`, and keeps
  legacy `string_len` decoded-byte count semantics.
- Legacy `print_i32`, `print_string`, `print_bool`, and `string_len` remain
  compatibility aliases, but new examples prefer `std.*` names.
- Promoted `std.*` names are reserved from user function/export shadowing.
- Unknown or unpromoted `std.*` calls use structured diagnostics; the
  suggested diagnostic code is `UnsupportedStandardLibraryCall`.
- Arity and type mismatches for promoted `std.*` calls use existing
  arity/type diagnostics where applicable.
- v1.5 does not promote `std.io.print_unit`, file IO, environment variables,
  process arguments, time, vectors/collections, allocation, user-defined
  standard modules, imports/packages, overloading, generic APIs, Unicode
  length semantics, or ABI/layout promises.

v1.6 memory and unsafe design slice release decisions:

- v1.6 was released 2026-05-17.
- The precise Slovo-side contract is
  `.llm/V1_6_MEMORY_UNSAFE_SLICE.md`.
- v1.6 promotes a reservation and gating contract, not raw-memory execution.
- Lexical `(unsafe ...)` remains the only unsafe boundary.
- `alloc`, `dealloc`, `load`, `store`, `ptr_add`, `unchecked_index`,
  `reinterpret`, and `ffi_call` are compiler-known reserved unsafe heads.
- Safe code using a reserved unsafe head must receive `UnsafeRequired` before
  ordinary call lookup.
- Code inside `(unsafe ...)` using a reserved unsafe head must receive
  `UnsupportedUnsafeOperation` until a future release defines semantics.
- User functions, imports, exports, and parameters cannot shadow reserved
  unsafe heads.
- Memory direction remains staged: safe values by default, future affine
  ownership, and explicit unsafe regions.
- v1.6 does not promote pointer types, allocation/free, load/store, pointer
  arithmetic, unchecked indexing, raw reinterpretation, FFI, stable ABI, or
  stable layout.

v1.7 developer experience hardening release decisions:

- v1.7 was released 2026-05-17.
- The precise Slovo-side contract is
  `.llm/V1_7_DEVELOPER_EXPERIENCE_HARDENING.md`.
- v1.7 is a tooling-only release over the v1.6 language contract.
- `glagol new <project-dir> [--name <name>]` scaffolds a valid v1.3-style
  project with `slovo.toml`, `src/main.slo`, and a small testable main module.
- `glagol new` must fail without overwriting non-empty directories.
- Plain `glagol fmt <file.slo>` remains stdout formatting.
- `glagol fmt --check <file-or-project>` checks canonical formatting without
  writing files.
- `glagol fmt --write <file-or-project>` writes canonical formatting for one
  file or all immediate project source modules.
- `glagol doc <file-or-project> -o <dir>` generates deterministic Markdown
  from source structure: modules, imports/exports, structs, functions, and
  tests.
- Documentation generation is not a semantic reflection API and does not claim
  typed-core, debug metadata, source-map, ABI, layout, or runtime reflection
  stability.
- A repo script or documented command entry point must run the full local v1
  release gate.
- LSP, watch mode, daemon protocols, SARIF, debug adapters, stable debug
  metadata, DWARF, and stable source-map files remain deferred.

v2.0.0-beta.1 experimental integration/readiness release decisions:

- `v2.0.0-beta.1` is a historical experimental release contract, released
  2026-05-17. The pushed tag name is historical and is not a beta maturity
  claim.
- The precise Slovo-side contract is
  `.llm/V2_0_0_BETA_1_RELEASE_CONTRACT.md`.
- Experimental readiness is based on v1.7 and adds no new source language
  syntax or semantics unless already implemented and gate-proven in Glagol.
- Experimental readiness means small real flat local projects can use
  `glagol new`, `check`, `fmt --check`, `fmt --write`, `test`, `build`,
  `doc`, artifact manifests, JSON diagnostics, and the release-gate script as
  one integrated workflow.
- The experimental language surface is the accumulated v1.1-v1.7 surface: `i32`,
  `bool`, builtin internal `unit`, tests, locals, `if`, `while`, structs,
  fixed direct scalar arrays with checked indexing, string value flow,
  option/result values and exact match slice, standard-runtime alpha, and
  lexical unsafe with reserved unsafe heads.
- Basic IO is only `std.io.print_i32`, `std.io.print_string`,
  `std.io.print_bool`, and `std.string.len`; file/env/process/time IO remains
  deferred.
- Vectors and growable collections are not experimental readiness
  requirements. Fixed arrays satisfy the experimental gate because this is an
  integration milestone; growable collections require allocation,
  ownership/lifetime, capacity, mutation, diagnostics, lowering, runtime
  tests, and docs that remain future beta work.
- Stable ABI/layout, FFI, raw-memory execution, LSP, stable debug metadata,
  stable source-map files, and package registries remain future beta work.

exp-1 owned runtime strings release decisions:

- exp-1 is the first experimental step toward `1.0.0-beta`.
- The precise Slovo-side contract is
  `.llm/EXP_1_OWNED_RUNTIME_STRINGS.md`.
- exp-1 promotes exactly one new source-level operation:
  `std.string.concat`.
- `std.string.concat` accepts two `string` values and returns an immutable
  runtime-owned `string`.
- Existing string equality, `std.string.len`, `std.io.print_string`, string
  locals, parameters, returns, and calls returning `string` apply to
  literal-backed and runtime-owned strings.
- No legacy `string_concat` alias is introduced.
- Allocation failure traps with
  `slovo runtime error: string allocation failed` and exits with code `1`.
- Runtime-owned string cleanup is compiler/runtime-owned and not
  source-visible.
- exp-1 keeps mutable strings, string containers, string indexing/slicing,
  user-visible allocation/deallocation, file IO, packages, generics, growable
  collections, raw-memory execution, FFI, and stable ABI/layout deferred.

The matching Glagol exp-4 gate has passed. The next planned implementation
stage is the next beta-roadmap slice after payloadless user-defined enums.

exp-2 collections alpha release decisions:

- exp-2 is a current experimental compiler-supported contract after matching
  Glagol exp-2 gates.
- The precise Slovo-side contract is
  `.llm/EXP_2_COLLECTIONS_ALPHA.md`.
- exp-2 promotes exactly one concrete growable vector type: `(vec i32)`.
- exp-2 promotes exactly four compiler-known standard-runtime operations:
  `std.vec.i32.empty`, `std.vec.i32.append`, `std.vec.i32.len`, and
  `std.vec.i32.index`.
- `std.vec.i32.append` accepts `(vec i32)` and `i32` and returns a new
  immutable runtime-owned `(vec i32)` without mutating the input vector.
- `std.vec.i32.len` returns `i32`; `std.vec.i32.index` returns `i32` and traps
  on invalid indices.
- Vector equality with `=` compares lengths and `i32` element values in order.
- Runtime trap texts are `slovo runtime error: vector allocation failed` and
  `slovo runtime error: vector index out of bounds`.
- exp-2 keeps generic vectors, non-`i32` element types, vector mutation,
  vector `var`/`set`, vector literals beyond empty/append construction,
  `push`, nested vectors, vectors in arrays/structs/options/results,
  iterators, slices, maps, sets, user-visible deallocation, stable
  ABI/layout/helper symbols, packages, and IO expansion deferred.

exp-3 standard IO and host environment release decisions:

- exp-3 is a current experimental compiler-supported contract after matching
  Glagol exp-3 gates.
- The precise Slovo-side contract is
  `.llm/EXP_3_STANDARD_IO_HOST_ENV.md`.
- exp-3 promotes exactly six compiler-known standard-runtime operations:
  `std.io.eprint`, `std.process.argc`, `std.process.arg`, `std.env.get`,
  `std.fs.read_text`, and `std.fs.write_text`.
- `std.io.eprint` accepts `string`, writes to stderr without adding a newline,
  and returns builtin `unit`.
- `std.process.argc` returns `i32`; `std.process.arg` accepts `i32` and
  returns `string`, trapping on out-of-range access with
  `slovo runtime error: process argument index out of bounds`.
- `std.env.get` accepts `string` and returns `string`; missing variables
  return the empty string for this stage.
- `std.fs.read_text` accepts `string` and returns `string`, trapping on host
  read failure with `slovo runtime error: file read failed`.
- `std.fs.write_text` accepts two `string` values and returns `0` on success
  or `1` on host failure.
- exp-3 keeps networking, async IO, binary file APIs, directory traversal,
  terminal control, platform abstraction, general host error ADTs, `result
  string Error`, package interaction, stdin full read/line iteration,
  randomness, time, stable ABI/layout, and stable helper symbols deferred.

exp-4 user data types and polymorphism release decisions:

- exp-4 is a current experimental compiler-supported contract after matching
  Glagol exp-4 gates.
- The precise Slovo-side contract is
  `.llm/EXP_4_USER_ADTS_ALPHA.md`.
- exp-4 promotes only payloadless user-defined enums:
  `(enum Name VariantA VariantB ...)`, with at least one variant.
- Variant values are constructed only through zero-argument qualified calls
  such as `(Name.VariantA)`.
- Enum values may flow through immutable locals, parameters, returns, calls,
  equality with `=`, and top-level tests.
- Enum `match` supports exhaustive payloadless variant arms with pattern
  syntax `((Name.VariantA) body...)`, one-or-more expression bodies, and common
  final result types.
- Runtime/backend representation is compiler-owned; exp-4 promises no stable
  layout, discriminant value, ABI, helper symbols, reflection, or conversion
  to `i32`.
- exp-4 keeps payload variants, tuple/record variants, generic enums, generic
  functions, type aliases, traits/interfaces/protocols, methods, derives,
  variant payload binding, wildcard/rest patterns, guards, nested patterns,
  enum values in arrays/options/results/vectors or nested structs beyond
  exp-18 direct fields, enum mutation, enum printing/ordering/hash,
  reflection, explicit discriminants, constructors with
  arguments, unqualified variant constructors, stable ABI/layout, and moving
  option/result to ordinary standard-library types deferred.

exp-6 C FFI scalar imports alpha release decisions:

- exp-6 is a released experimental contract, not beta maturity.
- The precise Slovo-side contract is
  `.llm/EXP_6_C_FFI_SCALAR_IMPORTS_ALPHA.md`.
- exp-6 promotes only top-level imported C function declarations with
  `i32`-only scalar parameters and `i32` or internal `unit` returns.
- Calls to imported C functions must occur inside lexical `(unsafe ...)`.
- `examples/ffi/exp-6-c-add/` is the minimal fixture target, with a `c_add`
  C companion and a safe Slovo wrapper.
- Artifact manifests must record foreign import metadata while marking the
  ABI/layout as experimental and fixture-scoped.
- exp-6 keeps pointer types, allocation/deallocation, raw unsafe heads
  execution, ownership/lifetime rules, C exports, headers, libraries, broad
  linker configuration, and stable ABI/layout deferred.

exp-7 test selection and test-run metadata alpha target decisions:

- exp-7 is a released experimental contract, not beta maturity.
- The precise Slovo-side release contract is
  `.llm/EXP_7_TEST_SELECTION_ALPHA.md`.
- exp-7 is narrowed to `glagol test <file.slo|project> --filter
  <substring>` plus legacy `glagol --run-tests --filter <substring>
  <file.slo>` while Glagol keeps the legacy route.
- Filtering is deterministic, case-sensitive substring matching against test
  display names.
- Selected tests execute in existing order; non-selected tests are skipped and
  counted.
- Zero matches is a successful run with explicit discovered, selected, passed,
  failed, and skipped counts.
- Test-run output and artifact manifests gain additive experimental metadata
  for total discovered, selected, passed, failed, skipped, and optional filter
  string.
- exp-7 keeps LSP, debug metadata, source maps, SARIF, watch/daemon
  protocols, documentation comments, lint categories, benchmarks, and new
  source language syntax deferred.

exp-8 host time and sleep alpha release decisions:

- exp-8 is a released experimental compiler-supported contract, not beta
  maturity.
- The precise Slovo-side release contract is
  `.llm/EXP_8_HOST_TIME_SLEEP_ALPHA.md`.
- exp-8 narrows the broad concurrency and long-running programs roadmap
  category to exactly `std.time.monotonic_ms: () -> i32` and
  `std.time.sleep_ms: (i32) -> unit`.
- `std.time.monotonic_ms` returns non-negative host monotonic elapsed
  milliseconds with an implementation-owned epoch.
- `std.time.sleep_ms` accepts non-negative `i32` millisecond durations; `0` is
  valid, and negative values reject or trap with
  `slovo runtime error: sleep_ms negative duration`.
- Test-runner support is deterministic for `sleep_ms 0`; `monotonic_ms`
  support is limited to structural tests or a non-negative host value.
- The exp-14 conformance-alignment release adds byte-identical Slovo fixtures
  `examples/supported/time-sleep.slo` and
  `examples/formatter/time-sleep.slo` for this already released exp-8
  behavior.
- Artifact manifests record standard-runtime time usage only if existing
  manifest patterns support standard-runtime usage metadata; otherwise extra
  time-specific metadata is deferred.
- exp-8 keeps threads, tasks, channels, async, cancellation, actors, shared
  memory, data-race freedom, scheduling guarantees, timers, wall-clock/
  calendar/timezone APIs, high-resolution timers, signal handling, source
  syntax, stable ABI/layout, and stable runtime helper symbols deferred.

exp-9 reliability, performance, and ecosystem hardening release decisions:

- exp-9 is a released experimental compiler-supported contract, not beta
  maturity.
- The precise Slovo-side release contract is
  `.llm/EXP_9_RELIABILITY_PERFORMANCE_ECOSYSTEM_HARDENING.md`.
- exp-9 is hardening-only over the released exp-8 baseline. It adds no source
  language syntax, type-system behavior, standard-runtime names, package
  features, manifest schema versions, runtime capabilities, stable
  ABI/layout promises, public performance guarantees, or beta claim.
- Matching Glagol gates must include property/fuzz-style parser, formatter,
  diagnostic, project graph, and promoted runtime API tests where feasible.
- Matching Glagol gates must include a source-reachable panic audit covering
  compiler, formatter, diagnostic, project graph, test-runner, backend,
  artifact-manifest, and runtime API paths.
- Matching Glagol gates must include benchmark fixtures or documented
  benchmark smoke, compatibility inventory for promoted experimental
  features, and a migration guide from `v2.0.0-beta.1` and exp releases.
- exp-9 keeps all language, standard-library, package-management, editor
  protocol, debug/source-map, broad FFI, raw-memory execution, stable
  benchmark-suite, stable ABI/layout, and beta-maturity expansion deferred.

exp-10 result-based host errors alpha release decisions:

- exp-10 is a released experimental compiler-supported contract, not beta
  maturity.
- The precise Slovo-side release contract is
  `.llm/EXP_10_RESULT_BASED_HOST_ERRORS_ALPHA.md`.
- exp-10 promotes exactly one new concrete result family:
  `(result string i32)`.
- exp-10 promotes exactly four additive compiler-known standard-runtime
  operations: `std.process.arg_result`, `std.env.get_result`,
  `std.fs.read_text_result`, and `std.fs.write_text_result`.
- The only promised ordinary host failure code is `err 1`.
- `std.fs.write_text_result` returns `ok 0` on success and `err 1` on
  ordinary host write failure.
- The existing exp-3 calls remain unchanged.
- Artifact manifests record exp-10 standard-runtime usage only if existing
  manifest patterns already record standard-runtime usage metadata; otherwise
  exp-10 adds no manifest schema fields.
- exp-10 keeps general host error ADTs, `result string Error`,
  platform-specific codes, result equality/printing/mapping, broader host API
  families, stable ABI/layout/helper symbols, and beta maturity deferred.

exp-11 basic randomness alpha release decisions:

- exp-11 is released experimental compiler support and not beta maturity.
- The precise Slovo-side release contract is
  `.llm/EXP_11_BASIC_RANDOMNESS_ALPHA.md`.
- exp-11 promotes exactly one compiler-known standard-runtime operation:
  `std.random.i32: () -> i32`.
- `std.random.i32` returns a non-negative implementation-owned pseudo-random
  or host-random `i32` suitable only for basic CLI use.
- Runtime/host inability to produce a value traps with exactly
  `slovo runtime error: random i32 unavailable`.
- Glagol test-runner behavior may use an implementation-owned deterministic
  non-negative sample or sequence.
- Artifact manifests record exp-11 standard-runtime usage only if existing
  manifest patterns already record standard-runtime usage metadata; otherwise
  exp-11 adds no manifest schema fields.
- exp-11 keeps seed APIs, crypto/security promises, bytes APIs, ranges,
  bounds, floats, random strings, UUIDs, broad `std.random.*`, stable
  ABI/layout/helper symbols, and beta maturity deferred.

exp-12 standard input result alpha release decisions:

- exp-12 is released experimental compiler support and not beta maturity.
- Release date: 2026-05-18.
- The precise Slovo-side release contract is
  `.llm/EXP_12_STDIN_RESULT_ALPHA.md`.
- exp-12 promotes exactly one compiler-known standard-runtime operation:
  `std.io.read_stdin_result: () -> (result string i32)`.
- `std.io.read_stdin_result` reads remaining stdin as text, returns `ok` text
  on success, returns `ok ""` for ordinary EOF with no bytes, and returns
  `(err string i32 1)` for ordinary host/input failure.
- Glagol test-runner behavior may use an implementation-owned fixed `ok`
  string.
- Artifact manifests record exp-12 standard-runtime usage only if existing
  manifest patterns already record standard-runtime usage metadata; otherwise
  exp-12 adds no manifest schema fields.
- exp-12 keeps trap stdin, line/prompt/terminal/binary/streaming/async stdin,
  encoding or Unicode promises beyond existing string bytes, stable
  ABI/layout/helper symbols, manifest schema changes, and beta maturity
  deferred.

exp-13 string parse i32 result alpha release decisions:

- exp-13 is released experimental compiler support and not beta maturity.
- Release date: 2026-05-18.
- The precise Slovo-side release contract is
  `.llm/EXP_13_STRING_PARSE_I32_RESULT_ALPHA.md`.
- exp-13 promotes exactly one compiler-known standard-runtime operation:
  `std.string.parse_i32_result: (string) -> (result i32 i32)`.
- `std.string.parse_i32_result` parses the entire string as ASCII decimal
  signed `i32`, with optional leading `-` and at least one digit.
- Success returns `(ok i32 i32 value)`.
- Empty input, non-digits, plus signs, whitespace, trailing bytes, non-ASCII
  digits, and out-of-range values return `(err i32 i32 1)`.
- The only ordinary parse error code promised by exp-13 is `err 1`.
- Release fixtures are `examples/supported/string-parse-i32-result.slo` and
  `examples/formatter/string-parse-i32-result.slo`.
- exp-13 keeps trap-based parse, parsing floats/bools/strings/bytes,
  whitespace/locale/base-prefix/underscore/plus-sign parsing, generic parse,
  parse error messages/codes, Unicode digit parsing, string indexing/slicing,
  tokenizer/scanner APIs, stdin line APIs, stable ABI/layout/helper symbols,
  manifest schema fields, and beta maturity deferred.

exp-14 standard runtime conformance alignment release decisions:

- exp-14 is released experimental conformance alignment and not beta maturity.
- The precise Slovo-side target contract is
  `.llm/EXP_14_STANDARD_RUNTIME_CONFORMANCE_ALIGNMENT.md`.
- exp-14 adds `STANDARD_RUNTIME.md` as the promoted compiler-known `std.*`
  operation catalog through exp-13.
- exp-14 adds byte-identical canonical fixtures
  `examples/supported/time-sleep.slo` and
  `examples/formatter/time-sleep.slo` for already released exp-8
  `std.time.monotonic_ms` and `std.time.sleep_ms 0`.
- The time/sleep fixtures require only structural/non-negative monotonic-time
  behavior and deterministic `sleep_ms 0`; they do not assert
  positive-duration timing.
- exp-14 requires the current supported fixture inventory to stay explicit and
  requires Slovo/Glagol supported and formatter fixtures to stay byte-aligned
  where matching files exist.
- exp-14 requires a fresh-project workflow covering `new`, `check`,
  `fmt --check`, `test`, `doc`, and `build` where the hosted toolchain
  exists.
- The workflow must exercise existing features together: modules/imports,
  tests, strings, `std.string.concat`, `std.string.parse_i32_result`, result
  `match`, `(vec i32)`, enum `match`, and `std.io.print_i32`.
- exp-14 release gates still include Slovo and Glagol diff checks,
  `cargo fmt --check`, `cargo test`, ignored promotion gate, binary smoke,
  LLVM smoke, and review `PASS`.
- exp-14 release gates passed with Slovo and Glagol diff checks,
  `cargo fmt --check`, `cargo test`, ignored promotion gate, binary smoke,
  LLVM smoke, focused conformance gate, and review `PASS`.
- exp-14 adds no source syntax, type forms, runtime APIs, compiler-known
  `std.*` names, standard library functions, manifest schema version,
  ABI/layout promise, runtime headers/libraries, or beta maturity.

exp-15 result helper standard names alpha decisions:

- The precise Slovo-side target contract is
  `.llm/EXP_15_RESULT_HELPER_STANDARD_NAMES_ALPHA.md`.
- exp-15 promotes preferred source-level `std.result.is_ok`,
  `std.result.is_err`, `std.result.unwrap_ok`, and
  `std.result.unwrap_err`.
- The names are accepted only for `(result i32 i32)` and
  `(result string i32)`.
- Legacy unqualified result helpers remain compatibility syntax where already
  supported.
- Release fixtures are `examples/supported/result-helpers.slo` and
  `examples/formatter/result-helpers.slo`.
- exp-15 keeps `std.result.map`, `std.result.unwrap_or`,
  `std.result.and_then`, option helper standard names, new payload families,
  generic result, user-defined error payloads, runtime ABI/layout claims,
  manifest schema changes, enum payloads, and beta maturity deferred.

exp-17 project enum imports alpha decisions:

- The precise Slovo-side target contract is
  `.llm/EXP_17_PROJECT_ENUM_IMPORTS_ALPHA.md`.
- exp-17 promotes explicit export/import of top-level enum names across local
  project modules and exp-5 workspace package modules.
- Imported enum types can be used in function signatures, immutable locals,
  calls/returns, same-enum equality, exhaustive enum matches, and qualified
  constructors.
- The enum surface is exactly exp-4 payloadless variants plus exp-16 unary
  `i32` payload variants.
- The project fixture is `examples/projects/enum-imports/`.
- exp-17 keeps non-`i32` enum payloads, multiple payloads, generics,
  containers, mutation, printing, ordering, hashing, reflection, stable
  ABI/layout, manifest schema changes, registry/package-manager claims, and
  beta maturity deferred.

exp-18 enum struct fields alpha decisions:

- The precise Slovo-side target contract is
  `.llm/EXP_18_ENUM_STRUCT_FIELDS_ALPHA.md`.
- exp-18 promotes direct struct field declarations whose field types are
  current user-defined enum type names.
- The enum field surface is exactly exp-4 payloadless variants plus exp-16
  unary `i32` payload variants.
- Struct construction, immutable struct local/parameter/return/call flow,
  field access, same-enum equality on field access, enum match on field
  access, tests, and `main` are in scope.
- Release fixtures are `examples/supported/enum-struct-fields.slo` and
  `examples/formatter/enum-struct-fields.slo`.
- exp-18 keeps wider enum payloads, arrays/vectors/options/results containing
  enum values, nested structs, struct mutation, enum mutation, printing,
  ordering, hashing, reflection, import aliases/globs/re-exports, stable
  ABI/layout, manifest schema changes, registry/package-manager claims,
  generics, and beta maturity deferred.

exp-19 primitive struct fields alpha decisions:

- The precise Slovo-side target contract is
  `.llm/EXP_19_PRIMITIVE_STRUCT_FIELDS_ALPHA.md`.
- exp-19 promotes direct struct field declarations whose field types are
  `bool` or immutable `string`, alongside already supported direct `i32` and
  exp-18 enum fields.
- Struct construction, immutable struct local/parameter/return/call flow,
  field access, bool predicate/test use, string equality, `std.string.len`,
  tests, and `main` are in scope.
- Release fixtures are `examples/supported/primitive-struct-fields.slo` and
  `examples/formatter/primitive-struct-fields.slo`.
- exp-19 keeps arrays/vectors/options/results, nested structs, struct
  mutation, string mutation, string ownership/cleanup guarantees beyond
  existing string behavior, broader string operations, printing beyond
  existing calls, package/import widening, stable ABI/layout, manifest schema
  changes, generics, methods, traits, and beta maturity deferred.

exp-20 f64 numeric primitive alpha decisions:

- The precise Slovo-side target contract is
  `.llm/EXP_20_F64_NUMERIC_PRIMITIVE_ALPHA.md`.
- exp-20 promotes direct `f64` function parameters, returns, immutable locals,
  calls, and decimal literals in `f64` contexts.
- Same-type `f64` `+`, `-`, `*`, `/`, `=`, `<`, `>`, `<=`, and `>=` plus
  `std.io.print_f64`, tests, and `main` returning `i32` are in scope.
- Release fixtures are `examples/supported/f64-numeric-primitive.slo` and
  `examples/formatter/f64-numeric-primitive.slo`.
- exp-20 keeps `f32`, wider/common integer types, char/bytes/decimal, numeric
  casts, mixed `i32`/`f64` arithmetic, f64 arrays/vectors/options/results,
  f64 enum payloads, f64 struct fields, `parse_f64`, random floats, stable
  ABI/layout, manifest schema changes, and beta maturity deferred.

## Phase 1: Stabilize The Contract

- [x] Split examples into compiler-supported and design/speculative groups.
- [x] Mark which examples Glagol can currently parse, check, and emit.
- [x] Keep `examples/supported/add.slo` aligned with Glagol's executable target.
- [x] Add notes to speculative examples saying they are design targets, not current compiler fixtures.
- [x] Keep `SPEC-v0.md` explicit about unimplemented v0 forms.
- [x] Keep README and examples docs explicit about the current supported subset.
- [x] Keep supported examples free of any form outside the current compiler contract.

## Phase 2: Make Tooling Real

- [x] Define canonical formatter rules for current supported syntax only.
- [x] Add formatter examples for modules, functions, calls, integer literals, `print_i32`, and binary `+`.
- [x] Add formatter examples for comparison and top-level `test` only after those forms become supported or are explicitly documented as design-target fixtures.
- [x] Add Slovo formatter fixtures for top-level `test` only after Glagol implements and tests the full strict contract.
- [x] Define parsed-tree printer output.
- [x] Define lowering-inspector output from surface AST to checked/core AST.
- [x] Define machine-diagnostic fixture format.

## Phase 3: Close Spec Gaps

- [x] Specify exact supported integer-literal range behavior for `i32`.
- [x] Specify `print_i32` as either a temporary compiler intrinsic or a standard-library/runtime binding.
- [x] Specify whether `unit` can be used as a user-declared return type in supported fixtures.
- [x] Specify when checked-but-not-lowered forms must emit `UnsupportedBackendFeature` instead of panicking.
- [x] Specify top-level `test` behavior enough for Glagol to implement it.
- [x] Coordinate remaining Glagol contract fixes and promotion tests before moving any `test` example into `examples/supported/`.
- [x] Specify `let`, `var`, and `set` checking and lowering.
- [x] Specify `while` checking and lowering.
- [x] Specify checked-expression spans as part of the compiler contract.
- [x] Specify line/column diagnostic ranges in addition to byte spans.
- [x] Specify the strict first-pass `i32` struct contract.
- [x] Specify the strict first-pass `i32` array constructor and literal
      checked-indexing contract.
- [x] Specify the strict first-pass `i32` option/result constructor contract.

## Phase 4: Grow The Core

- [x] Promote `let`, `var`, and `set` into supported examples and formatter fixtures.
- [x] Promote value-producing `if` into supported examples and formatter fixtures.
- [x] Promote first-pass `while` into supported examples and formatter fixtures.
- [x] Promote first-pass `i32` struct definitions, construction, and field access
      into supported examples and formatter fixtures.
- [x] Promote first-pass arrays and checked indexing into supported examples
      and formatter fixtures.
- [x] Promote first-pass `i32` option/result constructors into supported
      examples and formatter fixtures.
- [x] Promote lexical `unsafe` and unsafe-required diagnostics.
- [x] Runtime/string support or explicit unsupported diagnostics.

## Phase 5: Close v0

- [x] Promote `SPEC-v0.md` from draft sketch to the supported v0 contract.
- [x] Keep Glagol's binary CLI as the implementation-facing v0 tool surface.
- [x] Keep direct executable output, package management, broader type flow, raw
      memory, FFI, and ABI layout promises deferred until separate contracts.

## Phase 6: Start v1 Value Flow

- [x] Promote immutable struct locals, struct parameters, struct returns, calls
      returning structs, and field access through stored struct values.
- [x] Keep struct field/value mutation deferred beyond v1 unless explicitly
      promoted later.
- [x] Promote option/result value flow and tag observation.
- [x] Promote explicit trap-based `i32` option/result payload extraction.
- [x] Keep option/result matching, mapping, equality, printing, non-`i32`
      payloads and extraction, nested option/result values, arrays/structs
      containing option/results, and user-catchable exceptions deferred beyond
      v1 unless explicitly promoted later. v1.4 later promotes only the narrow
      `(option i32)` and `(result i32 i32)` match slice.
- [x] Promote array value flow, immutable array-local expression
      initialization, and dynamic indexing after layout and bounds behavior are
      specified.

## Phase 7: Start Runtime Strings

- [x] Promote the narrow runtime string slice: immutable source string literals
      with ASCII-plus-current-escape semantics, direct `print_string` calls, and
      borrowed immutable NUL-terminated compiler-emitted static storage.
- [x] Keep mutable string locals, string assignment, string
      ordering/comparison beyond equality, string arrays/struct
      fields/option-result payloads, slices, concatenation, indexing,
      ownership, user-defined runtime bindings, and stable string ABI promises
      deferred until separate contracts promote them; exp-1 later stages only
      `std.string.concat`.
- [x] Keep standard-runtime printing deferred for this phase; v1.5 later
      promotes only `std.io.print_i32`, `std.io.print_string`, and
      `std.io.print_bool` over the existing legacy aliases.
- [x] Keep unit printing unsupported; bool printing is promoted separately in
      v1.2 through `print_bool`.
- [x] Keep `unit` internal to supported unit-producing body forms; user-declared
      or stored `unit` values remain unsupported in v1.

## Phase 8: Improve v1 Tooling Contracts

- [x] Define `slovo.diagnostic` version `1` as the stable v1 machine
      diagnostic schema.
- [x] Define the v1 direction for preserving source spans through LLVM IR
      emission while deferring stable debug metadata and source-map files.
- [x] Define `slovo.artifact-manifest` version `1` for compiler outputs and
      test reports without requiring native executable output.
- [x] Define formatter stability guarantees for comments and nested forms:
      promoted formatter fixtures are idempotent canonical output, accepted
      full-line comment positions are preserved, unsupported comment/layout
      positions require structured diagnostics, `if` / `while` / `unsafe` keep
      stable multiline shapes, expression calls and constructors stay inline,
      and v1 makes no width-based reflow promise.
- [x] Specify the Stage 3 diagnostics coverage contract: Glagol must keep a
      golden machine-diagnostic fixture inventory for every current explicitly
      rejected v1 boundary. This marks the Slovo obligation as specified; it
      does not claim the Glagol inventory is complete.
- [x] Specify the Stage 3 lowering-inspector coverage contract: Glagol must
      keep textual inspector golden fixtures for add/canonical, top-level
      tests, locals, if, while, struct, struct value flow, array, array value
      flow, option/result, option/result flow, option/result payload,
      option/result match, string print, string value flow, print bool, unsafe,
      and formatter
      comments/stability only where inspector mode applies to source accepted
      by lowering.
- [x] Keep stable LLVM debug metadata, DWARF emission, and source-map files
      deferred; lowering-inspector fixtures are textual compiler-tree
      artifacts, not debug metadata.
- [x] Require future promoted features to add diagnostic and
      lowering-inspector coverage before promotion.

## Phase 9: Productize v1.1 Toolchain

- [x] Freeze v1.1 as a tooling release over the v1 language contract.
- [x] Define canonical single-file commands for `check`, `fmt`, `test`, and
      `build`.
- [x] Keep v1 source semantics and unsupported boundaries unchanged.
- [x] Define JSON diagnostics as a serialization of `slovo.diagnostic` version
      `1`.
- [x] Apply `slovo.artifact-manifest` version `1` manifests to v1.1 command
      invocations.
- [x] Define the stable v1.1 exit-code table.
- [x] Define hosted native build as LLVM IR plus Glagol runtime C plus Clang.
- [x] Document compatibility aliases as secondary Glagol routes, not primary
      Slovo commands.
- [x] Document v1.1 release gates and explicit deferrals.

## Phase 10: Freeze v1.2 Practical Runtime Values

- [x] Promote immutable string locals, string parameters, string returns, calls
      returning strings, string equality, string byte length through
      `string_len`, and top-level tests using string equality.
- [x] Promote `print_bool` with exact `true\n` / `false\n` output.
- [x] Keep `print_unit` unsupported because `unit` remains an internal builtin
      result type rather than a user-visible value.
- [x] Keep string concatenation deferred until allocation, ownership, lifetime,
      and deallocation semantics are specified; exp-1 later specifies the
      first narrow `std.string.concat` operation.
- [x] Define stable runtime trap messages and process exit code `1` for array
      bounds and option/result unwrap failures.
- [x] Preserve v1.1 CLI/toolchain assumptions and keep project mode/modules
      deferred.

## Phase 11: Freeze v1.3 Project Mode And Modules

- [x] Define `slovo.toml` as the v1.3 project manifest.
- [x] Define a flat source-root convention with default `src`.
- [x] Define project mode for `glagol check`, `glagol test`, and
      `glagol build`.
- [x] Keep single-file command behavior unchanged when the input is a `.slo`
      file.
- [x] Define module declarations, explicit local imports, and explicit export
      lists.
- [x] Limit importable declarations to exported top-level `fn` and `struct`
      names.
- [x] Require deterministic module ordering, test ordering, and manifest
      ordering.
- [x] Require multi-file source spans and artifact-manifest project fields.
- [x] Keep packages, dependencies, remote registries, version solving,
      workspaces, macros, public ABI, cross-package visibility, incremental
      builds, watch/LSP, path escapes, and generated code deferred.

## Phase 12: Freeze v1.4 Core Language Expansion

- [x] Promote source-level `match` for existing `(option i32)` and
      `(result i32 i32)` values.
- [x] Require exhaustive `some` / `none` and `ok` / `err` arms.
- [x] Define immutable payload bindings scoped to one arm only.
- [x] Define match arm bodies as one-or-more expression bodies whose final
      expression is the arm value.
- [x] Define match expression type as the common arm result type.
- [x] Name diagnostics for non-option/result subjects, unsupported payload
      types, missing arms, duplicate arms, malformed patterns, arm type
      mismatches, binding collisions, and unsupported mutation/container
      combinations.
- [x] Keep v1.3 project mode and v1.2 runtime values unchanged.
- [x] Keep user-defined enums/ADTs, generic payloads, mutation, vectors,
      `i64`, general block expressions, pattern guards, wildcard/rest
      patterns, destructuring, standard-library error conventions, ownership,
      and layout/ABI promises deferred.

## Phase 13: Freeze v1.5 Standard Library Alpha

- [x] Promote `std.io.print_i32` as the stable source-level standard-runtime
      name for legacy `print_i32` behavior.
- [x] Promote `std.io.print_string` as the stable source-level standard-runtime
      name for legacy `print_string` behavior.
- [x] Promote `std.io.print_bool` as the stable source-level standard-runtime
      name for legacy `print_bool` behavior.
- [x] Promote `std.string.len` as the stable source-level standard-runtime
      name for legacy `string_len` byte-count behavior.
- [x] Preserve legacy `print_i32`, `print_string`, `print_bool`, and
      `string_len` as compatibility aliases.
- [x] Require `UnsupportedStandardLibraryCall` diagnostics for unknown or
      unpromoted `std.*` calls.
- [x] Reserve promoted `std.*` names from user function/export shadowing.
- [x] Keep v1.5 names compiler-known, with no imports, packages,
      user-defined standard modules, or stable C ABI symbols.
- [x] Keep `std.io.print_unit`, file IO, environment variables, process args,
      time, vectors/collections, allocation, overloading, generic APIs,
      Unicode length semantics, and ABI/layout promises deferred.

## Phase 14: Freeze v1.6 Memory And Unsafe Design Slice

- [x] Keep lexical `(unsafe ...)` as the only unsafe boundary.
- [x] Reserve `alloc`, `dealloc`, `load`, `store`, `ptr_add`,
      `unchecked_index`, `reinterpret`, and `ffi_call` as compiler-known
      unsafe heads.
- [x] Require `UnsafeRequired` in safe code and
      `UnsupportedUnsafeOperation` inside lexical unsafe for reserved unsafe
      heads.
- [x] Reject user functions, imports, exports, and parameters that shadow
      reserved unsafe heads.
- [x] Keep raw-memory execution, pointer types, allocation/free, load/store,
      pointer arithmetic, unchecked indexing, reinterpretation, FFI, stable
      ABI, and stable layout deferred.

## Phase 15: Freeze v1.7 Developer Experience Hardening

- [x] Define `glagol new <project-dir> [--name <name>]` as a non-overwriting
      v1.3-style project scaffold command.
- [x] Preserve plain `glagol fmt <file.slo>` as stdout formatting.
- [x] Define `glagol fmt --check <file-or-project>` as non-writing canonical
      formatting verification.
- [x] Define `glagol fmt --write <file-or-project>` as in-place canonical
      formatting for one file or immediate project source modules.
- [x] Define `glagol doc <file-or-project> -o <dir>` as deterministic
      Markdown documentation generation from source structure.
- [x] Keep documentation generation separate from semantic reflection,
      typed-core APIs, debug metadata, source maps, ABI/layout, and runtime
      reflection.
- [x] Require a repo script or documented command entry point for the full
      local v1 release gate.
- [x] Keep LSP, watch mode, daemon protocols, SARIF, debug adapters, stable
      debug metadata, DWARF, and stable source-map files deferred.

## Phase 16: Freeze v2.0.0-beta.1 Experimental Integration Readiness

- [x] Mark `v2.0.0-beta.1` as a historical experimental release contract,
      released 2026-05-17, with future general-purpose beta work as the next
      planning horizon.
- [x] Define the release as an experimental integration/readiness release
      based on v1.7 rather than a new source-language release.
- [x] Require the small-flat-project workflow through `glagol new`, `check`,
      `fmt --check`, `fmt --write`, `test`, `build`, `doc`, artifact
      manifests, JSON diagnostics, and the release-gate script.
- [x] Freeze the experimental-supported language surface as the accumulated
      v1.1-v1.7 surface.
- [x] Limit experimental IO to `std.io.print_i32`, `std.io.print_string`,
      `std.io.print_bool`, and `std.string.len`; keep file/env/process/time IO
      deferred.
- [x] Reconcile older collection roadmap text by making fixed arrays
      sufficient for experimental readiness and deferring vectors/growable
      collections until future beta work.
- [x] Keep stable ABI/layout, FFI, raw-memory execution, LSP, stable debug
      metadata, stable source maps, and package registries out of the
      experimental release.

## Phase 17: Freeze exp-1 Owned Runtime Strings

- [x] Define exp-1 as experimental maturity and not beta.
- [x] Promote only compiler-known `std.string.concat` as the first
      heap-created owned runtime string operation.
- [x] Keep one source type, `string`, with literal-backed and runtime-owned
      implementation value kinds hidden from source code.
- [x] Require existing string equality, `std.string.len`,
      `std.io.print_string`, locals, parameters, returns, and calls to work
      over runtime-owned strings.
- [x] Define allocation-failure trap text and exit behavior.
- [x] Keep mutable strings, string containers, indexing, slicing,
      user-visible allocation/deallocation, file IO, packages, generics,
      growable collections, FFI, raw memory, and stable ABI/layout deferred.
- [x] Implement and gate the matching Glagol exp-1 behavior before claiming
      current compiler support.

## Phase 18: Freeze exp-2 Collections Alpha

- [x] Define exp-2 as experimental maturity and not beta.
- [x] Specify only one concrete vector type, `(vec i32)`, as the collections
      alpha source type.
- [x] Specify only compiler-known `std.vec.i32.empty`,
      `std.vec.i32.append`, `std.vec.i32.len`, and `std.vec.i32.index`.
- [x] Require `std.vec.i32.append` to return a new immutable runtime-owned
      vector without mutating its input.
- [x] Require `(vec i32)` locals, parameters, returns, calls, top-level tests,
      and vector equality with `=`.
- [x] Define allocation and index runtime trap texts.
- [x] Keep generic vectors, other element types, vector mutation,
      vector `var`/`set`, vector literals beyond empty/append construction,
      `push`, nested vectors, vectors in arrays/structs/options/results,
      iterators, slices, maps, sets, user deallocation, stable ABI/layout/helper
      symbols, packages, and IO expansion deferred.
- [x] Implement and gate the matching Glagol exp-2 behavior before claiming
      current compiler support.

## Phase 19: Freeze exp-3 Standard IO And Host Environment

- [x] Define exp-3 as experimental maturity and not beta.
- [x] Specify only six compiler-known host operations:
      `std.io.eprint`, `std.process.argc`, `std.process.arg`,
      `std.env.get`, `std.fs.read_text`, and `std.fs.write_text`.
- [x] Define `std.process.arg` out-of-range and `std.fs.read_text` host read
      failure as exact runtime traps for this stage.
- [x] Define missing environment variables as the empty string for this stage.
- [x] Define `std.fs.write_text` status as `0` on success and `1` on host
      failure for this stage.
- [x] Keep networking, async IO, binary file APIs, directory traversal,
      terminal control, platform abstraction, general host error ADTs,
      `result string Error`, package interaction, stdin full read/line
      iteration, randomness/time, and stable ABI/layout/helper symbols
      deferred.
- [x] Implement and gate the matching Glagol exp-3 behavior before claiming
      current compiler support.

## Phase 20: Freeze exp-4 User Data Types And Polymorphism

- [x] Define exp-4 as experimental maturity and not beta.
- [x] Specify only payloadless user-defined enums:
      `(enum Name VariantA VariantB ...)`.
- [x] Require at least one variant per enum declaration.
- [x] Require zero-argument qualified constructors such as `(Name.VariantA)`.
- [x] Allow enum values through immutable locals, parameters, returns, calls,
      same-enum equality, and top-level tests.
- [x] Define exhaustive enum `match` with payloadless qualified variant arms,
      one-or-more expression bodies, and common final result types.
- [x] Keep runtime/backend enum representation compiler-owned, with no stable
      layout, discriminant value, ABI, helper-symbol, reflection, or
      conversion-to-`i32` promise.
- [x] Defer payload variants, tuple/record variants, generic enums, generic
      functions, type aliases, traits/interfaces/protocols, methods, derives,
      variant payload binding, wildcard/rest patterns, guards, nested patterns,
      enum values in arrays/options/results/vectors or nested structs beyond
      exp-18 direct fields, enum mutation,
      enum printing/ordering/hash, reflection, explicit discriminants,
      constructors with arguments, unqualified variant constructors, stable
      ABI/layout, and moving option/result to ordinary standard-library types.
- [x] Implement and gate the matching Glagol exp-4 behavior before claiming
      current compiler support.
- [x] Freeze exp-20 as F64 Numeric Primitive Alpha: promote only direct `f64`
      value flow, decimal `f64` literals, same-type `f64`
      arithmetic/comparison, `std.io.print_f64`, byte-identical
      supported/formatter fixtures, and defer `f32`, wider/common integer
      types, char/bytes/decimal, casts, mixed numeric arithmetic, f64
      containers, f64 enum payloads, f64 struct fields, parsing, random
      floats, stable ABI/layout, manifest schema changes, and beta maturity.

## Deferred

These are future beta targets, not unresolved experimental release decisions.

- [ ] Package/dependency management.
- [ ] Build profiles, optimization flags, target triples, and
      cross-compilation.
- [ ] Stable object/library/header output and broad C FFI beyond exp-6 scalar
      imports alpha.
- [ ] Stdin formatting, recursive directory formatting, and dependency/package
      formatting.
- [ ] Project-wide test expansion beyond the existing baseline, event
      streams, and stable public benchmarks. exp-9 may require benchmark
      fixtures or documented benchmark smoke only.
- [ ] Editor integrations, LSP, SARIF, watch mode, and daemon protocols.
- [ ] Macros.
- [ ] Generics.
- [ ] Concurrency beyond the exp-8 host time/sleep alpha target.
- [ ] Advanced ownership or affine resources.
- [ ] String concatenation beyond exp-1 `std.string.concat`, indexing,
      slicing, mutable string locals, string containers, user-visible string
      allocation or deallocation, and stable string ABI/layout.
- [ ] Package manager.
- [ ] Full standard library beyond the v1.5 standard-runtime alpha.
- [ ] Direct x86/ARM backend.
- [ ] Struct field/value mutation.
- [ ] Option/result mapping, equality, printing, payloads and extraction
      beyond the explicitly promoted concrete result slices, nesting,
      containers, generic payloads, user-defined payload ADTs, and
      user-catchable exceptions.
- [ ] Unit printing and broader standard-runtime printing.
- [ ] Host IO beyond exp-3 and the exp-10 `*_result` slice, networking,
      async IO, binary file APIs, directory traversal, terminal control,
      platform abstraction, general host error ADTs, stdin full read/line
      iteration, time beyond the exp-8 host time/sleep target, randomness
      beyond the exp-11 target,
      vectors/collections beyond the current concrete `(vec i32)` and
      `(vec i64)` slices, user-defined standard modules, overloading, and
      generic standard-library APIs.
- [ ] Generic vectors, vector element families beyond the current concrete
      `i32` and `i64` slices, vector mutation, vector literals beyond
      empty/append construction, nested vectors, vectors in
      arrays/structs/options/results, iterators, slices, maps, sets, user
      deallocation, and stable vector ABI/layout/helper symbols.
- [ ] User-declared or stored `unit` values.
- [ ] Pointer types, raw memory operations, unchecked indexing, and broad FFI
      beyond exp-6 scalar imports alpha.
- [ ] Stable ABI and stable layout promises.