slovo/docs/language/ROADMAP.md

# 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.8`, released on 2026-05-22 as the first post-beta
concrete type alias foundation 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. JSON parsing,
recursive JSON values, generic aliases, parameterized aliases, cross-module
alias visibility, maps/sets, 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: `1.0.0-beta.9`, likely generics and collection
unification. The exact scope must be frozen from the manifest and roadmap
before implementation.

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.