# 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.17`, released on 2026-05-22 as a post-beta JSON primitive scalar parsing foundation. 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, the `1.0.0-beta.6` loopback networking foundation, `1.0.0-beta.7` compact JSON text construction, `1.0.0-beta.8` concrete type aliases, `1.0.0-beta.9` collection alias unification and generic reservation, `1.0.0-beta.10` API discovery, `1.0.0-beta.11` local package API documentation, `1.0.0-beta.12` concrete vector helper parity, `1.0.0-beta.13` diagnostic catalog and schema policy, `1.0.0-beta.14` benchmark suite catalog and metadata gate, `1.0.0-beta.15` reserved generic collection boundary hardening and collection ledger, and `1.0.0-beta.16` string scanning and token boundary helpers. `1.0.0-beta.16` adds `std.string` source facades and examples for `byte_at_result`, `slice_result`, `starts_with`, and `ends_with`. These helpers are byte-oriented over the current NUL-terminated runtime string representation; invalid indexes and ranges return `err 1`, and substring allocation failure may use the existing string allocation trap policy. `1.0.0-beta.16` does not add Unicode scalar, grapheme, display-width, or locale semantics; full JSON parsing; object/array parsing; tokenizer objects; language slice/view syntax; mutable strings; stable ABI/layout; performance claims; or a stable stdlib/API freeze. The current stage adds primitive scalar JSON token parse facades for booleans, concrete numeric primitives, and exact `null` only. JSON string parsing, object/array parsing, recursive JSON values, tokenizers, whitespace-tolerant document parsing, schema validation, streaming, Unicode escape handling, stable ABI/layout, and stable stdlib/API freeze remain deferred. Full JSON parsing, JSON string/object/array parsing, recursive JSON values, executable generics, generic aliases, parameterized aliases, cross-module alias visibility, maps/sets, traits, inference, monomorphization, iterators, runtime changes for generic collections, DNS, TLS, UDP, async IO, non-loopback binding, HTTP frameworks, rich host-error ADTs, stable ABI/layout, stable Markdown schema, stable stdlib/API compatibility freeze, LSP/watch, SARIF/daemon protocols, stable `1.0.0` diagnostics freeze, re-exports/globs/hierarchical modules, mutable vectors, language slice/view APIs, additional runtime names, Unicode/grapheme string semantics, timing publication, performance claims, stable benchmark JSON schema, and package registry semantics remain deferred. Next stage target: continue after `1.0.0-beta.17` from developer-experience, package, benchmark metadata, collection, or string-processing planning without claiming executable generics, an LSP/watch protocol, SARIF/daemon protocol, stable Markdown schema, registry semantics, stable benchmark JSON schema, stable `1.0.0` diagnostics freeze, stable standard-library/API compatibility freeze, mutable vectors, language slice/view APIs, additional runtime names, Unicode/grapheme semantics, full JSON parsing, maps/sets, iterators, or performance claims until the exact scope is frozen from the manifest and roadmap. The final experimental precursor scope is `exp-125`, defined in `.llm/EXP_125_UNSIGNED_U32_U64_NUMERIC_AND_STDLIB_BREADTH_ALPHA.md`. Its unsigned direct-value flow, parse/format runtime lanes, and matching staged stdlib helper breadth are now absorbed into `1.0.0-beta`. The last tagged experimental alpha before beta is `exp-124`, defined in `.llm/EXP_124_FIXED_ARRAY_ENUM_AND_STRUCT_ELEMENTS_ALPHA.md`. The previous released experimental alpha contract is `exp-123`, defined in `.llm/EXP_123_OWNED_VECTOR_BENCHMARK_SUITE_EXTENSION_AND_WHITEPAPER_REFRESH_ALPHA.md`, for one connected benchmark/publication refresh. It keeps the exp-121 language surface unchanged while refreshing the current whitepaper baseline and the documented nine-kernel benchmark suite around `math-loop`, `branch-loop`, `parse-loop`, `array-index-loop`, `string-eq-loop`, `array-struct-field-loop`, `enum-struct-payload-loop`, `vec-i32-index-loop`, and `vec-string-eq-loop`, with local-machine evidence only, no threshold claim, and no beta claim. The previous released experimental alpha contract is `exp-122`, defined in `.llm/EXP_122_COMPOSITE_DATA_BENCHMARK_SUITE_EXTENSION_AND_WHITEPAPER_REFRESH_ALPHA.md`, for one connected benchmark/publication refresh. It kept the exp-121 language surface unchanged while refreshing the earlier whitepaper baseline and the documented seven-kernel benchmark suite around `math-loop`, `branch-loop`, `parse-loop`, `array-index-loop`, `string-eq-loop`, `array-struct-field-loop`, and `enum-struct-payload-loop`, with local-machine evidence only, no threshold claim, and no beta claim. The previous released experimental alpha contract is `exp-121`, defined in `.llm/EXP_121_NON_RECURSIVE_STRUCT_ENUM_PAYLOADS_ALPHA.md`, for one connected broadening of the enum payload surface. It allows unary enum payload variants to use current known non-recursive struct types, while keeping exactly one payload per payload variant, a conservative same-payload-type-per-enum rule when payload variants are present, existing immutable enum flow through locals/params/returns/calls/tests/main, existing `match` payload binding and field access behavior, no enum equality requirement for struct-payload enums, no direct array/vec/option/result payloads, no recursion, and no beta claim. The previous released experimental alpha contract is `exp-120`, defined in `.llm/EXP_120_FIXED_ARRAY_STRUCT_FIELDS_ALPHA.md`, for one connected broadening of the struct-field surface. It adds direct struct fields over the current promoted fixed immutable array family `(array i32 N)`, `(array i64 N)`, `(array f64 N)`, `(array bool N)`, and `(array string N)`, while keeping array lengths positive only, arrays and structs immutable only, checked indexing on `i32` expressions only, no field mutation, no array mutation, and no beta claim. The earlier released experimental alpha contract is `exp-119`, defined in `.llm/EXP_119_BENCHMARK_SUITE_EXTENSION_AND_WHITEPAPER_REFRESH_ALPHA.md`, for one connected benchmark/publication refresh. It keeps the exp-118 language surface unchanged while refreshing the earlier whitepaper baseline and the documented five-kernel benchmark suite around `math-loop`, `branch-loop`, `parse-loop`, `array-index-loop`, and `string-eq-loop`, with local-machine evidence only, no threshold claim, and no beta claim. The previous released experimental alpha contract is `exp-118`, defined in `.llm/EXP_118_STRING_FIXED_ARRAYS_ALPHA.md`, for one connected broadening of the fixed-array surface. It adds `(array string N)` alongside the earlier direct scalar array family, while keeping array lengths positive only, arrays immutable only, checked indexing on `i32` expressions only, arrays in struct fields out of scope at that earlier boundary, and no beta claim. The previous released experimental alpha contract is `exp-117`, defined in `.llm/EXP_117_DIRECT_SCALAR_FIXED_ARRAYS_ALPHA.md`, for one connected broadening of the fixed-array surface. It adds direct scalar element families `i64`, `f64`, and `bool` alongside the existing `i32` lane, while keeping array lengths positive only, arrays immutable only, checked indexing on `i32` expressions only, string arrays out of scope at that earlier boundary, and no beta claim. The previous released experimental alpha contract is `exp-116`, defined in `.llm/EXP_116_DIRECT_SCALAR_AND_STRING_ENUM_PAYLOADS_ALPHA.md`, for one connected broadening of the enum payload surface. It adds unary direct `i64`, `f64`, `bool`, and `string` payload variants alongside payloadless variants and the existing unary `i32` lane, while keeping exactly one payload per payload variant, a conservative same-payload-kind-per-enum rule, containers and composite payloads out of scope, and no beta claim. The previous released experimental alpha contract is `exp-115`, defined in `.llm/EXP_115_COMPOSITE_STRUCT_FIELDS_AND_NESTED_STRUCTS_ALPHA.md`, for one connected broadening of the struct-field surface. It adds current concrete vec, option, and result families plus current known non-recursive struct types as direct struct fields, alongside the already-supported direct scalar, immutable string, and current enum field families, without broadening arrays as fields, field mutation, recursive/cyclic layouts, adding new runtime calls, or claiming beta maturity. The previous released experimental alpha contract is `exp-114`, defined in `.llm/EXP_114_MUTABLE_COMPOSITE_LOCALS_ALPHA.md`, for one connected broadening of the local-value surface. It adds same-type mutable whole-value reassignment for `string`, the current concrete vec families, the current concrete option/result families, current known struct values, and current enum values, without broadening arrays, field/element/payload mutation, adding new runtime calls, or claiming beta maturity. The previous released experimental alpha contract is `exp-113`, defined in `.llm/EXP_113_MUTABLE_SCALAR_LOCALS_ALPHA.md`, for one connected broadening of the local-value surface. It adds direct mutable `bool`, `i64`, and `f64` locals declared with `var` and reassigned with `set` from already promoted same-type scalar expressions, without broadening string/vector/option/result/ struct/enum mutation, adding new runtime calls, or claiming beta maturity. The previous released experimental alpha contract is `exp-112`, defined in `.llm/EXP_112_IMMUTABLE_BOOL_LOCALS_ALPHA.md`, for one connected broadening of the local-value surface. It adds direct immutable `bool` locals declared with `let`, initialized from already promoted bool expressions, and reusable in existing predicate, return, call, test, and `main` positions, without adding mutable bool locals, bool assignment, new runtime calls, or a beta claim. The previous released experimental alpha contract is `exp-111`, defined in `.llm/EXP_111_STANDARD_IO_STDIN_SOURCE_HELPERS_ALPHA.md`, for one connected broadening of the concrete `std.io` facade. It adds `read_stdin_result`, `read_stdin_option`, `read_stdin_or`, `read_stdin_i32_result`, `read_stdin_i32_option`, `read_stdin_i32_or_zero`, `read_stdin_i32_or`, `read_stdin_i64_result`, `read_stdin_i64_option`, `read_stdin_i64_or_zero`, `read_stdin_i64_or`, `read_stdin_f64_result`, `read_stdin_f64_option`, `read_stdin_f64_or_zero`, `read_stdin_f64_or`, `read_stdin_bool_result`, `read_stdin_bool_option`, `read_stdin_bool_or_false`, and `read_stdin_bool_or` while staying source-authored over the promoted `std.io.read_stdin_result`, `std.string.parse_*_result`, and exp-109 bridge helpers only, without adding compiler-known std names, generics, new runtime calls, or a beta claim. The previous released experimental alpha contract is `exp-109`, defined in `.llm/EXP_109_STANDARD_OPTION_AND_RESULT_BRIDGE_HELPERS_ALPHA.md`, for one connected broadening of the concrete `std.option` and `std.result` facades. It adds `some_or_err_i32`, `some_or_err_i64`, `some_or_err_f64`, `some_or_err_bool`, `some_or_err_string`, `ok_or_none_i32`, `ok_or_none_i64`, `ok_or_none_string`, `ok_or_none_f64`, and `ok_or_none_bool` while staying source-authored over the existing concrete option/result families only, without adding compiler-known std names, generics, or a beta claim. The previous released experimental alpha contract is `exp-108`, defined in `.llm/EXP_108_STANDARD_VEC_STRING_F64_AND_BOOL_PREFIX_AND_SUFFIX_HELPERS_ALPHA.md`, for one connected broadening of the concrete `std.vec_string`, `std.vec_f64`, and `std.vec_bool` facades. It adds `starts_with`, `without_prefix`, `ends_with`, and `without_suffix` to all three modules while staying source-authored, recursive, and immutable over the existing vec-string, vec-f64, and vec-bool runtime families only, without adding compiler-known std names, generics, or a beta claim. The previous released experimental alpha contract is `exp-106`, defined in `.llm/EXP_106_STANDARD_VEC_F64_AND_BOOL_OPTION_QUERY_HELPERS_ALPHA.md`, for one connected broadening of the concrete `std.vec_f64` and `std.vec_bool` facades. It adds `index_option`, `first_option`, `last_option`, `index_of_option`, and `last_index_of_option` to both modules while staying source-authored, recursive, and immutable over the existing vec-f64 and vec-bool runtime families and the already promoted concrete option families only, without adding compiler-known std names, generics, edit helpers, or a beta claim. The previous released experimental alpha contract is `exp-104`, defined in `.llm/EXP_104_STANDARD_VEC_BOOL_BASELINE_ALPHA.md`, for the first usable `std.vec_bool` baseline facade over the sibling concrete `(vec bool)` runtime family. It freezes the baseline direct wrappers, builder helpers, query helpers, and the simple real-program helpers `contains` and `count_of` without widening compiler semantics beyond concrete `(vec bool)` flow and equality, and without adding generics, option/result helpers, transform/edit helpers, or a beta claim. The previous released experimental alpha contract is `exp-102`, defined in `.llm/EXP_102_STANDARD_OPTION_BOOL_AND_F64_BASELINE_ALPHA.md`, for one connected broadening of the concrete `std.option` facade and the conservative option core-language slice. It adds the concrete `(option f64)` and `(option bool)` helper families to `std/option.slo`, broadens immutable value flow, extraction, and source-level `match` to those same families, and keeps the whole slice explicit and concrete without adding compiler-known std names, generic option semantics, or a beta claim. The earlier released experimental alpha contract is `exp-101`, defined in `.llm/EXP_101_STANDARD_VEC_STRING_OPTION_AND_TRANSFORM_HELPERS_ALPHA.md`, for one connected broadening of the concrete `std.vec_string` facade. It adds the option-query helpers `index_option`, `first_option`, `last_option`, `index_of_option`, and `last_index_of_option`, plus the transform helpers `concat`, `take`, `drop`, `reverse`, and `subvec`, while staying source-authored, recursive, and immutable over the existing vec-string runtime family without adding compiler-known std names, generics, edit helpers, or a beta claim. The earlier released experimental alpha contract is `exp-100`, defined in `.llm/EXP_100_STANDARD_OPTION_STRING_BASELINE_ALPHA.md`, for the first concrete `(option string)` baseline on top of the existing option slice. It broadens `std/option.slo` with concrete string constructors, observers, and fallback helpers, and broadens immutable option value flow, payload extraction, and source-level `match` to `(option string)` without adding compiler-known std names, generic option semantics, or a beta claim. The earlier released experimental alpha contract is `exp-99`, defined in `.llm/EXP_99_STANDARD_VEC_STRING_BASELINE_ALPHA.md`, for the first usable `std.vec_string` baseline facade over the sibling concrete `(vec string)` runtime family. It adds the required direct wrappers, builder helpers, query helpers, and simple real-program helpers as one connected source-authored slice without widening compiler semantics beyond concrete `(vec string)` flow and equality, and without adding generics, helper families beyond the frozen baseline, or a beta claim. The earlier released experimental alpha contract is `exp-98`, defined in `.llm/EXP_98_STANDARD_VEC_I64_EDIT_HELPERS_ALPHA.md`, for connected edit helpers on top of the existing `std.vec_i64` baseline facade. It adds `insert_at`, `insert_range`, `replace_at`, `replace_range`, `remove_at`, and `remove_range` as one connected source-authored slice, keeps the full vec_i64 source family recursive and immutable, and does not add compiler-known std names, generics, or a beta claim. The earlier released experimental alpha contract is `exp-97`, defined in `.llm/EXP_97_STANDARD_VEC_I64_TRANSFORM_HELPERS_ALPHA.md`, for narrow transform helpers on top of the existing `std.vec_i64` baseline facade. It adds `concat`, `take`, `drop`, `reverse`, and `subvec` as one connected source-authored slice, keeps the full vec_i64 source family recursive and immutable, and does not add compiler-known std names, insert/replace/remove helpers, generics, or a beta claim. The earlier released experimental alpha contract is `exp-96`, defined in `.llm/EXP_96_STANDARD_VEC_I64_OPTION_QUERY_HELPERS_ALPHA.md`, for concrete option-query helpers on top of the existing `std.vec_i64` baseline facade. It adds `index_option`, `first_option`, `last_option`, `index_of_option`, and `last_index_of_option` as one connected source-authored slice, keeps the module self-contained through raw current `(option i64)` and `(option i32)` forms instead of `std.option`, keeps the full vec_i64 source family recursive and immutable, and does not add compiler-known std names, transform/range/edit helpers, generics, or a beta claim. The earlier released experimental alpha contract is `exp-95`, defined in `.llm/EXP_95_STANDARD_OPTION_I64_BASELINE_ALPHA.md`, for the first concrete `(option i64)` baseline on top of the existing option slice. It broadens `std/option.slo` with the `i64` constructor, observer, and fallback helper surface, and broadens immutable option value flow, payload extraction, and source-level `match` to `(option i64)` without adding compiler-known std names, generic option semantics, or a beta claim. The earlier released `exp-94` is defined in `.llm/EXP_94_STANDARD_VEC_I64_BASELINE_ALPHA.md`, for the first usable `std.vec_i64` baseline facade over the sibling concrete `(vec i64)` runtime family. It adds the required direct wrappers, builder helpers, query helpers, and simple real-program helpers as one connected source-authored slice without widening compiler semantics or adding new Slovo-side compiler-known runtime names. It remains experimental maturity, not a beta claim. The earlier released `exp-93` is defined in `.llm/EXP_93_STANDARD_VEC_I32_COUNT_OF_HELPER_ALPHA.md`, for one new public `std.vec_i32` helper, `count_of`, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim. The earlier released `exp-92` is defined in `.llm/EXP_92_STANDARD_VEC_I32_WITHOUT_PREFIX_HELPER_ALPHA.md`, for one new public `std.vec_i32` helper, `without_prefix`, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim. The earlier released `exp-91` is defined in `.llm/EXP_91_STANDARD_VEC_I32_WITHOUT_SUFFIX_HELPER_ALPHA.md`, for one new public `std.vec_i32` helper, `without_suffix`, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim. The earlier released `exp-90` is defined in `.llm/EXP_90_STANDARD_VEC_I32_ENDS_WITH_HELPER_ALPHA.md`, for one new public `std.vec_i32` helper, `ends_with`, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim. The earlier released `exp-89` is defined in `.llm/EXP_89_STANDARD_VEC_I32_STARTS_WITH_HELPER_ALPHA.md`, for one new public `std.vec_i32` helper, `starts_with`, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim. The earlier released `exp-88` is defined in `.llm/EXP_88_STANDARD_VEC_I32_REPLACE_RANGE_HELPER_ALPHA.md`, for one new public `std.vec_i32` helper, `replace_range`, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim. The earlier released `exp-87` is defined in `.llm/EXP_87_STANDARD_VEC_I32_INSERT_RANGE_HELPER_ALPHA.md`, for one new public `std.vec_i32` helper, `insert_range`, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim. The earlier released `exp-86` is defined in `.llm/EXP_86_STANDARD_VEC_I32_REMOVE_RANGE_HELPER_ALPHA.md`, for one new public `std.vec_i32` helper, `remove_range`, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim. The earlier released `exp-85` is defined in `.llm/EXP_85_STANDARD_VEC_I32_SUBVEC_HELPER_ALPHA.md`, for one new public `std.vec_i32` helper, `subvec`, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim. The earlier released `exp-84` is defined in `.llm/EXP_84_STANDARD_VEC_I32_INSERT_HELPER_ALPHA.md`, for one new public `std.vec_i32` helper, `insert_at`, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim. The earlier released `exp-83` is defined in `.llm/EXP_83_STANDARD_VEC_I32_REMOVE_HELPER_ALPHA.md`, for one new public `std.vec_i32` helper, `remove_at`, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim. The earlier released `exp-82` is defined in `.llm/EXP_82_STANDARD_VEC_I32_REPLACE_HELPER_ALPHA.md`, for one new public `std.vec_i32` helper, `replace_at`, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim. The earlier released `exp-81` is defined in `.llm/EXP_81_STANDARD_VEC_I32_RANGE_HELPER_ALPHA.md`, for one new public `std.vec_i32` helper, `range`, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim. The earlier released `exp-80` is defined in `.llm/EXP_80_STANDARD_VEC_I32_GENERATED_CONSTRUCTOR_HELPERS_ALPHA.md`, for narrow generated constructor helpers layered onto the existing `std.vec_i32` source facade over the promoted `(vec i32)` runtime family. The earlier released `exp-79` is defined in `.llm/EXP_79_STANDARD_VEC_I32_TRANSFORM_HELPERS_ALPHA.md`, for narrow recursive transform helpers layered onto the existing `std.vec_i32` source facade over the promoted `(vec i32)` runtime family. It remains experimental maturity, not a beta claim. The earlier released `exp-78` is defined in `.llm/EXP_78_STANDARD_CLI_LOCAL_SOURCE_FACADE_ALPHA.md`, for the unchanged `std.cli` helper surface recorded as the Slovo-side contract for the sibling Glagol local-source gate over the existing `std.process` and `std.string` source facades. It remains experimental maturity, not a beta claim. The earlier released `exp-77` is defined in `.llm/EXP_77_STANDARD_VEC_I32_OPTION_QUERY_HELPERS_ALPHA.md`, for concrete option-returning query helpers layered onto the current `std.vec_i32` source facade over the promoted `(vec i32)` runtime family. It remains experimental maturity, not a beta claim. The earlier released `exp-76` is defined in `.llm/EXP_76_STANDARD_VEC_I32_SOURCE_HELPERS_ALPHA.md`, for a concrete `std.vec_i32` source facade over the current promoted `(vec i32)` runtime family. It remains experimental maturity, not a beta claim. The earlier released `exp-75` is defined in `.llm/EXP_75_STANDARD_OPTION_CONSTRUCTORS_ALPHA.md`, for source-authored concrete option constructors over the current promoted `(option i32)` family. It remains experimental maturity, not a beta claim. The earlier released `exp-74` is defined in `.llm/EXP_74_STANDARD_RESULT_CONSTRUCTOR_HELPERS_ALPHA.md`, for source-authored concrete result constructors over the current promoted result families. It remains experimental maturity, not a beta claim. The earlier released `exp-73` is defined in `.llm/EXP_73_STANDARD_IO_VALUE_HELPERS_ALPHA.md`, for source-authored value-returning IO print helpers over the current promoted print runtime calls. It remains experimental maturity, not a beta claim. The earlier released `exp-72` is defined in `.llm/EXP_72_STANDARD_CLI_CUSTOM_FALLBACK_HELPERS_ALPHA.md`, for source-authored typed CLI argument custom-fallback helpers over the current argument lookup and concrete parse result families. It remains experimental maturity, not a beta claim. The earlier released `exp-71` is defined in `.llm/EXP_71_STANDARD_PROCESS_CUSTOM_FALLBACK_HELPERS_ALPHA.md`, for source-authored typed process argument custom-fallback helpers over the current argument lookup and concrete parse result families. It remains experimental maturity, not a beta claim. The earlier released `exp-70` is defined in `.llm/EXP_70_STANDARD_FS_CUSTOM_FALLBACK_HELPERS_ALPHA.md`, for source-authored typed filesystem read custom-fallback helpers over the current text-read and concrete parse result families. It remains experimental maturity, not a beta claim. The earlier released `exp-69` is defined in `.llm/EXP_69_STANDARD_ENV_CUSTOM_FALLBACK_HELPERS_ALPHA.md`, for source-authored typed environment parse custom-fallback helpers over the current environment lookup and concrete parse result families. It remains experimental maturity, not a beta claim. The earlier released `exp-68` is defined in `.llm/EXP_68_STANDARD_STRING_CUSTOM_FALLBACK_HELPERS_ALPHA.md`, for source-authored typed string parse custom-fallback helpers over the current concrete parse result families. It remains experimental maturity, not a beta claim. The earlier released `exp-67` is defined in `.llm/EXP_67_STANDARD_PROCESS_TYPED_HELPERS_ALPHA.md`, for source-authored typed process argument result/fallback helpers over the current argument lookup and concrete parse result families. It remains experimental maturity, not a beta claim. The earlier released `exp-66` is defined in `.llm/EXP_66_STANDARD_FS_TYPED_READ_HELPERS_ALPHA.md`, for source-authored typed filesystem read result/fallback helpers over the current text-read and concrete parse result families. It remains experimental maturity, not a beta claim. The earlier released `exp-65` is defined in `.llm/EXP_65_STANDARD_ENV_TYPED_HELPERS_ALPHA.md`, for source-authored typed environment parse result/fallback helpers over the current environment lookup and concrete parse result families. It remains experimental maturity, not a beta claim. The earlier released `exp-64` is defined in `.llm/EXP_64_STANDARD_NUM_FALLBACK_HELPERS_ALPHA.md`, for source-authored checked conversion fallback helpers over the current numeric result families. It remains experimental maturity, not a beta claim. The earlier released `exp-63` is defined in `.llm/EXP_63_STANDARD_FS_FALLBACK_HELPERS_ALPHA.md`, for source-authored filesystem fallback/status helpers over the current `(result string i32)` and `(result i32 i32)` families. It remains experimental maturity, not a beta claim. The earlier released `exp-62` is defined in `.llm/EXP_62_STANDARD_ENV_FALLBACK_HELPERS_ALPHA.md`, for source-authored environment presence/fallback helpers over the current `(result string i32)` family. It remains experimental maturity, not a beta claim. The earlier released `exp-61` is defined in `.llm/EXP_61_STANDARD_PROCESS_FALLBACK_HELPERS_ALPHA.md`, for source-authored process argument fallback helpers over the current `(result string i32)` family. It remains experimental maturity, not a beta claim. The earlier released `exp-60` is defined in `.llm/EXP_60_STANDARD_STRING_FALLBACK_HELPERS_ALPHA.md`, for source-authored string parse fallback helpers over the current concrete parse result families. It remains experimental maturity, not a beta claim. The earlier released `exp-59` is defined in `.llm/EXP_59_HOSTED_BUILD_OPTIMIZATION_AND_BENCHMARK_PUBLICATION_ALPHA.md`, for the earlier benchmark/publication baseline paired with Glagol exp-59. It keeps the exp-58 language surface unchanged and remains experimental maturity, not a beta claim. The earlier released `exp-58` is defined in `.llm/EXP_58_BOOLEAN_LOGIC_ALPHA.md`, for boolean `and`, `or`, and `not` forms lowered through existing `if` semantics. The earlier released `exp-57` is defined in `.llm/EXP_57_INTEGER_BITWISE_ALPHA.md`, for explicit integer bitwise heads over same-width `i32` and `i64` operands plus source-authored `std.math` bitwise wrappers. The earlier released `exp-56` is defined in `.llm/EXP_56_INTEGER_REMAINDER_ALPHA.md`, for integer remainder `%` over same-width `i32` and `i64` operands plus source-authored `std.math` remainder/even/odd helpers. The earlier released `exp-55` is defined in `.llm/EXP_55_RESULT_F64_BOOL_SOURCE_FLOW_ALPHA.md`, for concrete `f64` and `bool` result constructors and source `match` payload bindings. The earlier released `exp-54` is defined in `.llm/EXP_54_STANDARD_CLI_TYPED_ARGUMENTS_ALPHA.md`, for typed argument parse helpers in the staged CLI facade module. The earlier released `exp-53` is defined in `.llm/EXP_53_STANDARD_CLI_SOURCE_FACADE_ALPHA.md`, for explicit project-mode source search of the staged CLI facade module. The earlier released `exp-52` is defined in `.llm/EXP_52_STANDARD_PROCESS_FACADE_SOURCE_SEARCH_ALPHA.md`, for explicit project-mode source search of the staged process facade module. The earlier released `exp-51` is defined in `.llm/EXP_51_STANDARD_LIBRARY_PATH_LIST_ALPHA.md`, for ordered `SLOVO_STD_PATH` discovery of explicit standard-library source imports. The earlier released `exp-50` is defined in `.llm/EXP_50_INSTALLED_STANDARD_LIBRARY_DISCOVERY_ALPHA.md`, for installed toolchain discovery of explicit standard-library source imports. The earlier released `exp-49` is defined in `.llm/EXP_49_STANDARD_IO_FACADE_SOURCE_SEARCH_ALPHA.md`, for explicit project-mode source search of the staged IO facade module. The earlier released `exp-48` is defined in `.llm/EXP_48_STANDARD_CORE_FACADE_SOURCE_SEARCH_ALPHA.md`, for explicit project-mode source search of staged core facade modules. The earlier released `exp-47` is defined in `.llm/EXP_47_STANDARD_HOST_FACADE_SOURCE_SEARCH_ALPHA.md`, for explicit project-mode source search of staged host facade modules. The earlier released `exp-46` is defined in `.llm/EXP_46_WORKSPACE_STANDARD_SOURCE_SEARCH_ALPHA.md`, for explicit workspace-package standard source search. The earlier released `exp-45` is defined in `.llm/EXP_45_STANDARD_RESULT_OPTION_SOURCE_SEARCH_ALPHA.md`, for explicit project-mode `std.result` and `std.option` source search. The earlier released `exp-44` is defined in `.llm/EXP_44_STANDARD_LIBRARY_SOURCE_SEARCH_ALPHA.md`, for explicit project-mode `std.math` source search. The earlier released `exp-43` is defined in `.llm/EXP_43_TECHNICAL_WHITEPAPERS_AND_SKILLS_ALPHA.md`, for technical whitepapers, PDF publication artifacts, and beta language-design skills. The earlier released `exp-42` is defined in `.llm/EXP_42_HOT_LOOP_BENCHMARK_MODE_ALPHA.md`, for hot-loop benchmark mode alignment. It remains experimental maturity, not a beta claim, and does not change the exp-39 language surface. The earlier released `exp-41`, Lisp Benchmark Comparison Alpha, is defined in `.llm/EXP_41_LISP_BENCHMARK_COMPARISON_ALPHA.md` for Lisp-family benchmark comparison alignment. The earlier released `exp-40`, Benchmark Suite And License Alpha, is defined in `.llm/EXP_40_BENCHMARK_SUITE_AND_LICENSE_ALPHA.md` for benchmark-suite alignment, project licensing, and release naming criteria. The earlier released `exp-39`, Standard Math Extensions And Benchmark Scaffold Alpha, is defined in `.llm/EXP_39_STANDARD_MATH_EXTENSIONS_AND_BENCHMARK_SCAFFOLD_ALPHA.md` for source-authored math helper extensions in `std/math.slo` and matching Glagol benchmark scaffold gates. The earlier released `exp-38`, Standard Host Source Facades Alpha, is defined in `.llm/EXP_38_STANDARD_HOST_SOURCE_FACADES_ALPHA.md` and remains part of the experimental history. The earlier released `exp-37`, Standard Time Source Facade Alpha, is defined in `.llm/EXP_37_STANDARD_TIME_SOURCE_FACADE_ALPHA.md` and remains part of the experimental history. The earlier released `exp-36`, Standard Option Source Helpers Alpha, is defined in `.llm/EXP_36_STANDARD_OPTION_SOURCE_HELPERS_ALPHA.md` and remains part of the experimental history. The earlier released `exp-35`, Standard Result Bool Source Helpers Alpha, is defined in `.llm/EXP_35_STANDARD_RESULT_BOOL_SOURCE_HELPERS_ALPHA.md` and remains part of the experimental history. The earlier released `exp-34`, String Parse Bool Result Alpha, is defined in `.llm/EXP_34_STRING_PARSE_BOOL_RESULT_ALPHA.md` and remains part of the experimental history. The earlier released `exp-33`, Standard Result Source Helpers Alpha, is defined in `.llm/EXP_33_STANDARD_RESULT_SOURCE_HELPERS_ALPHA.md` and remains part of the experimental history. The earlier released `exp-32`, Standard Math Source Helpers Alpha, is defined in `.llm/EXP_32_STANDARD_MATH_SOURCE_HELPERS_ALPHA.md` and remains part of the experimental history. The earlier released `exp-31`, Checked F64 To I64 Result Alpha, is defined in `.llm/EXP_31_CHECKED_F64_TO_I64_RESULT_ALPHA.md` and remains part of the experimental history. The earlier released `exp-30`, Standard Library Source Layout Alpha, is defined in `.llm/EXP_30_STANDARD_LIBRARY_SOURCE_LAYOUT_ALPHA.md` and remains part of the experimental history. The earlier released `exp-29`, Numeric Struct Fields Alpha, is defined in `.llm/EXP_29_NUMERIC_STRUCT_FIELDS_ALPHA.md` and remains part of the experimental history. The current released experimental alignment is `exp-14`, Standard Runtime Conformance Alignment, defined in `.llm/EXP_14_STANDARD_RUNTIME_CONFORMANCE_ALIGNMENT.md`. It adds no source syntax, type forms, runtime APIs, compiler-known `std.*` names, standard library functions, manifest schema version, ABI/layout promise, runtime headers/libraries, or beta maturity. Release maturity policy lives in `.llm/RELEASE_MATURITY_POLICY.md`. All current releases are experimental maturity; beta is reserved for the general-purpose threshold. ## Definition Of Supported An example is compiler-supported only when Glagol can parse it, lower it, type-check it, emit LLVM for it, and the behavior is covered by an automated test. Partial compiler recognition does not count as support. A checked form that can still reach a backend panic, lacks diagnostics, or lacks tests remains a design target. Current supported subset: - `examples/supported/add.slo` - `examples/supported/top-level-test.slo` - `examples/supported/local-variables.slo` - `examples/supported/composite-locals.slo` - `examples/supported/composite-struct-fields.slo` - `examples/supported/if.slo` - `examples/supported/while.slo` - `examples/supported/struct.slo` - `examples/supported/struct-value-flow.slo` - `examples/supported/array.slo` - `examples/supported/array-value-flow.slo` - `examples/supported/array-direct-scalars.slo` - `examples/supported/array-direct-scalars-value-flow.slo` - `examples/supported/array-string.slo` - `examples/supported/array-string-value-flow.slo` - `examples/supported/array-struct-fields.slo` - `examples/supported/enum-payload-structs.slo` - `examples/supported/option-result.slo` - `examples/supported/option-result-flow.slo` - `examples/supported/option-result-payload.slo` - `examples/supported/option-result-match.slo` - `examples/supported/string-print.slo` - `examples/supported/string-value-flow.slo` - `examples/supported/print-bool.slo` - `examples/supported/standard-runtime.slo` - `examples/supported/unsafe.slo` - `examples/supported/time-sleep.slo` - `examples/supported/string-parse-i32-result.slo` - `examples/supported/result-helpers.slo` - `examples/supported/enum-payload-i32.slo` - `examples/supported/enum-payload-direct-scalars.slo` - `examples/supported/enum-struct-fields.slo` - `examples/supported/primitive-struct-fields.slo` - `examples/supported/f64-numeric-primitive.slo` - `examples/supported/i64-numeric-primitive.slo` - `examples/supported/numeric-widening-conversions.slo` - `examples/supported/checked-i64-to-i32-conversion.slo` - `examples/supported/integer-to-string.slo` - `examples/supported/string-parse-i64-result.slo` - `examples/supported/f64-to-string.slo` - `examples/supported/f64-to-i32-result.slo` - `examples/supported/string-parse-f64-result.slo` - `examples/supported/numeric-struct-fields.slo` - `examples/supported/f64-to-i64-result.slo` - `examples/supported/string-parse-bool-result.slo` - `(module name)` - top-level `(struct Name (field i32)...)` - top-level `(fn ...)` - top-level `(test "name" body... final-expression)` - explicit `i32` parameters and `i32` returns, plus direct `(option i32)` and `(result i32 i32)` constructor returns - integer literals, parameter references, binary `+`, user function calls, legacy compiler/runtime compatibility alias `print_i32`, equality comparison `=`, ordering comparison `<`, and final-expression returns - local `i32` bindings with `let` and `var`, local references after declaration, and mutable local assignment with `set` - value-producing `if` - first-pass `while` as a non-final sequential body form - first-pass struct construction and immediate field access - first v1 struct value flow through immutable locals, parameters, returns, calls returning structs, and stored field access - fixed direct scalar array constructors over `i32`, `i64`, `f64`, and `bool`, immutable array locals, and literal checked indexing - fixed direct scalar array value flow through immutable array locals initialized from matching array-valued expressions, fixed array parameters, returns, calls returning arrays, and runtime-checked dynamic indexing - first-pass `i32` option/result constructors as direct function returns - first v1 option/result value flow through immutable locals, parameters, calls returning option/result values, and `is_some` / `is_none` / `is_ok` / `is_err` tag observation - first v1 trap-based `i32` option/result payload extraction with `unwrap_some`, `unwrap_ok`, and `unwrap_err` - v1.4 source-level `match` for existing `(option i32)` and `(result i32 i32)` values, with exhaustive arms, immutable arm-scoped payload bindings, one-or-more expression arm bodies, and common arm result types - exp-10 concrete `(result string i32)` with the same narrow result flow, observers, unwraps, and `match` shape used by existing `(result i32 i32)` support - exp-15 preferred result helper standard names `std.result.is_ok`, `std.result.is_err`, `std.result.unwrap_ok`, and `std.result.unwrap_err` for only `(result i32 i32)`, `(result i64 i32)`, and `(result string i32)`, plus `(result f64 i32)` where promoted by exp-28, with legacy unqualified result helpers retained as compatibility syntax - exp-16 user-defined enum variants carrying exactly one `i32` payload, qualified unary constructors, immutable arm-local payload bindings in exhaustive enum `match`, enum value flow through locals, parameters, returns, calls, tests, and `main`, and same-enum tag-plus-payload equality - exp-120 direct struct fields over fixed immutable arrays `(array i32 N)`, `(array i64 N)`, `(array f64 N)`, `(array bool N)`, and `(array string N)`, with immutable struct flow and checked indexing after field access - exp-121 unary enum payload variants over current known non-recursive struct types, with one payload per payload variant, one payload type per enum when payload variants are present, immutable enum flow, and `match` payload binding exposing existing field access behavior - exp-118 fixed immutable arrays over `string`, with positive literal lengths, direct construction, immutable local value flow, parameters, returns, calls returning arrays, and checked indexing with `i32` expressions only - exp-117 fixed immutable arrays over direct scalar element families `i32`, `i64`, `f64`, and `bool`, with positive literal lengths, direct construction, immutable local value flow, parameters, returns, calls returning arrays, and checked indexing with `i32` expressions only - exp-116 user-defined enum variants carrying exactly one direct `i64`, `f64`, `bool`, or `string` payload in addition to the existing unary `i32` lane, with the same one-binding exhaustive `match` shape, immutable value flow, and same-enum tag-plus-payload equality, while keeping one direct payload kind per enum when payload variants are present - exp-18 enum-typed struct fields using the current exp-4 payloadless and exp-16 unary `i32` enum surfaces, with struct construction, immutable struct flow, field access, same-enum equality on field access, and enum match on field access - exp-19 primitive struct fields using direct `bool` and immutable `string` field types alongside direct `i32` and exp-18 enum fields, with struct construction, immutable struct flow, field access, bool predicate use, string equality, and `std.string.len` - exp-112 immutable bool locals using direct immutable `let` locals declared as `bool`, initialized from already promoted bool expressions, and flowing into existing predicate, return, call, test, and `main` positions - exp-113 mutable scalar locals using direct mutable `var` locals declared as `bool`, `i64`, and `f64`, plus same-type `set` reassignment from already promoted scalar expressions - exp-114 mutable composite locals using same-type whole-value `var` / `set` reassignment for `string`, current concrete vec families, current concrete option/result families, current known struct values, and current enum values - exp-115 composite struct fields and nested structs using direct struct field declarations over current concrete vec families, current concrete option/result families, and current known non-recursive struct types, alongside the already supported direct scalar, immutable string, and current enum field families - exp-20 f64 numeric primitive using direct `f64` parameters, returns, immutable locals, calls, decimal literals, same-type `f64` arithmetic and comparison, and `std.io.print_f64` - exp-21 i64 numeric primitive using direct `i64` parameters, returns, immutable locals, calls, explicit signed decimal `i64` literal atoms, same-type `i64` arithmetic and comparison, and `std.io.print_i64` - exp-22 numeric widening conversions using explicit `std.num.i32_to_i64 : (i32) -> i64`, `std.num.i32_to_f64 : (i32) -> f64`, and `std.num.i64_to_f64 : (i64) -> f64` calls over the existing numeric primitives - exp-23 checked i64-to-i32 conversion using explicit `std.num.i64_to_i32_result : (i64) -> (result i32 i32)`, returning `ok` for signed `i32` range values and `err 1` for out-of-range values - exp-24 integer to string formatting using explicit `std.num.i32_to_string : (i32) -> string` and `std.num.i64_to_string : (i64) -> string`, returning decimal signed ASCII text with `-` only for negative values and no leading `+` - exp-25 string parse i64 result using explicit `std.string.parse_i64_result : (string) -> (result i64 i32)`, returning `ok value` for in-range ASCII signed decimal `i64` text and `err 1` for parse failure or out-of-range input - exp-26 f64 to string formatting using explicit `std.num.f64_to_string : (f64) -> string`, returning finite decimal ASCII text for promoted finite `f64` values - exp-27 checked f64-to-i32 result conversion using explicit `std.num.f64_to_i32_result : (f64) -> (result i32 i32)`, returning `ok` value only for finite, exactly integral inputs inside the signed `i32` range and `err 1` for non-finite, fractional, or out-of-range input - exp-28 string parse f64 result using explicit `std.string.parse_f64_result : (string) -> (result f64 i32)`, returning `ok value` for complete finite ASCII decimal `f64` text and `err 1` for ordinary parse failure, non-finite text, trailing or leading unsupported characters, or out-of-domain input - exp-29 numeric struct fields using direct immutable `i64` and finite `f64` field types alongside already supported direct `i32`, `bool`, immutable `string`, and current enum fields, with constructors, immutable struct flow, field access, existing same-type numeric arithmetic/comparison, and existing numeric print/format helpers - exp-30 standard library source layout using `std/` as the staged source home for standard library modules and examples, including narrow source-authored `std/math.slo` helpers and source wrappers over already promoted compiler-known calls, without automatic `std` imports or new compiler-known `std.*` names - exp-31 checked f64-to-i64 result conversion using explicit `std.num.f64_to_i64_result : (f64) -> (result i64 i32)`, returning `ok` value only for finite, exactly integral inputs inside the signed `i64` range and `err 1` for non-finite, fractional, or out-of-range input - exp-32 standard math source helpers in staged `std/math.slo`, adding source-authored `i64` and finite `f64` `abs`, `min`, `max`, `clamp`, and `square` coverage without new compiler-known `std.*` runtime names - exp-39 standard math extension helpers in staged `std/math.slo`, adding source-authored `neg`, `cube`, zero/positive/negative predicates, and inclusive `in_range` coverage for `i32`, `i64`, and finite `f64` without broad math or benchmark-performance claims - exp-33 standard result source helpers in staged `std/result.slo`, adding concrete `is_err_*` and `unwrap_err_*` wrappers for already promoted concrete result families plus `unwrap_or_i32`, `unwrap_or_i64`, `unwrap_or_string`, and `unwrap_or_f64` without new compiler-known `std.*` runtime names - exp-34 string parse bool result using explicit `std.string.parse_bool_result : (string) -> (result bool i32)`, returning `ok true` for exactly `true`, `ok false` for exactly `false`, and `err 1` for empty input, uppercase/mixed-case text, leading/trailing whitespace, numeric text, or any other text - exp-35 standard result bool source helpers in staged `std/result.slo`, adding `is_ok_bool`, `is_err_bool`, `unwrap_ok_bool`, `unwrap_err_bool`, and `unwrap_or_bool` for `(result bool i32)` without new compiler-known `std.*` runtime names, generic result helpers, or stable ABI/layout claims - exp-36 standard option source helpers in staged `std/option.slo`, adding `is_some_i32`, `is_none_i32`, `unwrap_some_i32`, and `unwrap_or_i32` for `(option i32)` without new compiler-known `std.*` runtime names, generic option helpers, automatic `std` imports/search, or stable ABI/layout claims - exp-37 standard time source facade in staged `std/time.slo`, adding `monotonic_ms` and `sleep_ms_zero` wrappers over the already released exp-8 time calls without new compiler-known `std.*` runtime names, automatic `std` imports/search, wall-clock/calendar/timezone APIs, high-resolution timers, async timers, cancellation, scheduling guarantees, or stable ABI/layout claims - first runtime string slice for immutable source string literals passed directly to legacy compiler/runtime compatibility alias `print_string`, which prints the string plus a newline and returns builtin `unit` - v1.2 immutable string value flow through `let` locals, parameters, returns, calls returning strings, string equality, string byte length through `string_len`, and top-level tests using string equality - legacy compiler/runtime compatibility alias `print_bool`, which prints `true` or `false` plus a newline and returns builtin `unit` - v1.5 standard-runtime alpha names `std.io.print_i32`, `std.io.print_string`, `std.io.print_bool`, and `std.string.len`, with legacy `print_i32`, `print_string`, `print_bool`, and `string_len` retained as compatibility aliases - exp-8 host time/sleep alpha names `std.time.monotonic_ms: () -> i32` and `std.time.sleep_ms: (i32) -> unit`, with deterministic `sleep_ms 0` and only structural/non-negative `monotonic_ms` checks in conformance fixtures - lexical `unsafe` expression blocks containing otherwise supported safe body forms, plus `UnsafeRequired` / `UnsupportedUnsafeOperation` diagnostics for raw unsafe operation heads reserved by v1.6: `alloc`, `dealloc`, `load`, `store`, `ptr_add`, `unchecked_index`, `reinterpret`, and `ffi_call` Current exp-1 fixture support: - `examples/supported/owned-string-concat.slo` - `examples/formatter/owned-string-concat.slo` - compiler-known `std.string.concat` with signature `(string, string) -> string`, producing immutable runtime-owned strings Current exp-2 fixture support: - `examples/supported/vec-i32.slo` - `examples/formatter/vec-i32.slo` - one concrete growable vector type `(vec i32)` - compiler-known `std.vec.i32.empty`, `std.vec.i32.append`, `std.vec.i32.len`, and `std.vec.i32.index` - vector equality with `=` These are current compiler-supported exp-2 fixtures. Current exp-3 fixture support: - `examples/supported/host-io.slo` - `examples/formatter/host-io.slo` - compiler-known `std.io.eprint`, `std.process.argc`, `std.process.arg`, `std.env.get`, `std.fs.read_text`, and `std.fs.write_text` - process argument out-of-range and file read failure as exact runtime traps - missing environment variables as empty strings - text file write status `0` on success and `1` on host failure These are current compiler-supported exp-3 fixtures. Current exp-8 release fixtures: - `examples/supported/time-sleep.slo` - `examples/formatter/time-sleep.slo` - compiler-known `std.time.monotonic_ms: () -> i32` - compiler-known `std.time.sleep_ms: (i32) -> unit` - non-negative host monotonic elapsed milliseconds with implementation-owned epoch - deterministic `sleep_ms 0` - no positive-duration timing assertion These are current compiler-supported exp-8 fixtures aligned by the released exp-14 conformance release. Current exp-12 release fixtures: - `examples/supported/stdin-result.slo` - `examples/formatter/stdin-result.slo` - compiler-known `std.io.read_stdin_result: () -> (result string i32)` - remaining stdin text as `ok` - ordinary EOF with no bytes as `ok ""` - ordinary host/input failure as `err 1` - deterministic-enough test-runner behavior through an implementation-owned fixed `ok` string These are current compiler-supported exp-12 fixtures. Current exp-13 release fixtures: - `examples/supported/string-parse-i32-result.slo` - `examples/formatter/string-parse-i32-result.slo` - compiler-known `std.string.parse_i32_result: (string) -> (result i32 i32)` - entire ASCII decimal signed `i32` parsing with optional leading `-` - success as `(ok i32 i32 value)` - ordinary parse failure as `(err i32 i32 1)` - structural composition with `std.io.read_stdin_result` without assuming a particular stdin payload These are current compiler-supported exp-13 fixtures. Current exp-15 released fixtures: - `examples/supported/result-helpers.slo` - `examples/formatter/result-helpers.slo` - compiler-known `std.result.is_ok` and `std.result.is_err` for `(result i32 i32)` and `(result string i32)` - compiler-known `std.result.unwrap_ok` returning `i32` for `(result i32 i32)` and `string` for `(result string i32)` - compiler-known `std.result.unwrap_err` returning `i32` for both supported result families - legacy unqualified `is_ok`, `is_err`, `unwrap_ok`, and `unwrap_err` remain compatibility syntax where already supported These are released Slovo-side exp-15 fixtures with matching Glagol gates. Current exp-10 compiler-supported fixtures: - `examples/supported/host-io-result.slo` - `examples/formatter/host-io-result.slo` - concrete `(result string i32)` values - compiler-known `std.process.arg_result`, `std.env.get_result`, `std.fs.read_text_result`, and `std.fs.write_text_result` - ordinary host failure as `err 1` - exp-3 calls unchanged Current exp-11 release fixtures: - `examples/supported/random.slo` - `examples/formatter/random.slo` - compiler-known `std.random.i32: () -> i32` - non-negative implementation-owned random `i32` values for basic CLI use - exact unavailable trap: `slovo runtime error: random i32 unavailable` Current exp-4 fixture support: - `examples/supported/enum-basic.slo` - `examples/formatter/enum-basic.slo` - payloadless `(enum Name VariantA VariantB ...)` declarations with at least one variant - zero-argument qualified constructors such as `(Name.VariantA)` - enum values through immutable locals, parameters, returns, calls, equality, and top-level tests - exhaustive payloadless enum `match` arms with common final result types These are current compiler-supported exp-4 fixtures. Current exp-16 fixture support: - `examples/supported/enum-payload-i32.slo` - `examples/formatter/enum-payload-i32.slo` - enum declarations mixing payloadless variants and unary `i32` payload variants - zero-argument constructors for payloadless variants and qualified unary constructors for payload variants - enum values through immutable locals, parameters, returns, calls, equality, top-level tests, and `main` - exhaustive enum `match` arms with immutable arm-local payload bindings for payload variants - same-enum equality by tag for payloadless variants and by tag plus payload for payload variants These are released experimental exp-16 fixtures. Current exp-121 fixture support: - `examples/supported/enum-payload-structs.slo` - `examples/formatter/enum-payload-structs.slo` - unary enum payload variants over current known non-recursive struct types - one payload per payload variant and one payload type per enum when payload variants are present - qualified constructors, immutable enum locals, parameters, returns, calls, tests, and `main` - exhaustive `match` payload binding exposing the struct payload for existing field access and checked indexing through array-bearing struct fields These are released experimental exp-121 fixtures. Current exp-120 fixture support: - `examples/supported/array-struct-fields.slo` - `examples/formatter/array-struct-fields.slo` - direct struct field declarations over fixed immutable arrays with element families `i32`, `i64`, `f64`, `bool`, and `string` - struct construction from matching fixed-array expressions - immutable struct locals, parameters, returns, calls, tests, and `main` for structs carrying those field types - field access returning the declared fixed-array type for existing checked indexing with `i32` expressions These are released experimental exp-120 fixtures. Current exp-118 fixture support: - `examples/supported/array-string.slo` - `examples/formatter/array-string.slo` - `examples/supported/array-string-value-flow.slo` - `examples/formatter/array-string-value-flow.slo` - fixed immutable arrays over `string` - positive literal lengths only, immutable arrays only, and checked indexing with `i32` expressions only - direct constructors, immutable array locals, parameters, returns, calls returning arrays, top-level tests, and `main` These are released experimental exp-118 fixtures. Current exp-117 fixture support: - `examples/supported/array-direct-scalars.slo` - `examples/formatter/array-direct-scalars.slo` - `examples/supported/array-direct-scalars-value-flow.slo` - `examples/formatter/array-direct-scalars-value-flow.slo` - fixed immutable arrays over direct scalar element families `i32`, `i64`, `f64`, and `bool` - positive literal lengths only, immutable arrays only, and checked indexing with `i32` expressions only - direct constructors, immutable array locals, parameters, returns, calls returning arrays, top-level tests, and `main` These are released experimental exp-117 fixtures. Current exp-116 fixture support: - `examples/supported/enum-payload-direct-scalars.slo` - `examples/formatter/enum-payload-direct-scalars.slo` - enum declarations mixing payloadless variants and unary direct `i64`, `f64`, `bool`, or `string` payload variants - one payload per payload variant, with one direct payload kind per enum when payload variants are present - zero-argument constructors for payloadless variants and qualified unary constructors for payload variants - enum values through immutable locals, parameters, returns, calls, equality, top-level tests, and `main` - exhaustive enum `match` arms with one immutable arm-local payload binding for payload variants These are released experimental exp-116 fixtures. Released exp-17 project contract fixture: - `examples/projects/enum-imports/` - export lists may include top-level enum names in project/workspace modules - import lists may import exported enum names - imported enum types may be used in function signatures, immutable locals, calls/returns, equality, exhaustive enum matches, and qualified constructors - the enum surface remains exactly exp-4 payloadless variants plus exp-16 unary `i32` payload variants This is a released experimental exp-17 fixture. It does not claim beta maturity or widen manifests, packages, enum payloads, generics, containers, mutation, printing, ordering, hashing, reflection, or stable ABI/layout. Current exp-18 fixture support: - `examples/supported/enum-struct-fields.slo` - `examples/formatter/enum-struct-fields.slo` - direct struct fields whose types are current user-defined enum names - struct construction with payloadless and unary `i32` enum field values - immutable struct locals, parameters, returns, calls, tests, and `main` - field access returning enum values - same-enum equality and exhaustive enum `match` on field access This is a released experimental exp-18 fixture. It does not claim beta maturity or widen enum payloads, containers, nested structs, mutation, printing, ordering, hashing, reflection, import behavior, manifest schema, package-manager behavior, or stable ABI/layout. Current exp-19 fixture support: - `examples/supported/primitive-struct-fields.slo` - `examples/formatter/primitive-struct-fields.slo` - direct struct fields whose types are `i32`, `bool`, or immutable `string` - struct construction with `i32`, `bool`, and immutable `string` field values - immutable struct locals, parameters, returns, calls, tests, and `main` - field access returning primitive values - bool field access in predicate/test positions - string field equality and `std.string.len` on field access This is a released experimental exp-19 fixture. It does not claim beta maturity or widen arrays, vectors, options, results, nested structs, mutation, string ownership/cleanup guarantees, broader string operations, printing, package/import behavior, manifest schema, generics, methods, traits, or stable ABI/layout. Current exp-115 fixture support: - `examples/supported/composite-struct-fields.slo` - `examples/formatter/composite-struct-fields.slo` - direct struct field declarations using current concrete vec families - direct struct field declarations using current concrete option/result families - direct struct field declarations using current known non-recursive struct types - coexistence with the already supported direct `i32`, `bool`, immutable `string`, `i64`, finite `f64`, and current enum field families - immutable struct locals, parameters, returns, calls, tests, and `main` for structs carrying those fields - field access returning those composite field values for use with existing vec indexing, option/result `match`, string/number helpers, enum `match`, and nested struct helper flow This is a released experimental exp-115 fixture alignment. It does not claim beta maturity or add arrays as struct fields, field mutation, recursive/cyclic layouts, imports, runtime names, or stable ABI/layout. Current exp-114 fixture support: - `examples/supported/composite-locals.slo` - `examples/formatter/composite-locals.slo` - same-type mutable whole-value `var` / `set` reassignment for `string`, current concrete vec families, current concrete option/result families, current known struct values, and current enum values - fixed arrays remain immutable and field/element/payload mutation stays out of scope This is a released experimental exp-114 fixture alignment. It does not claim beta maturity or add mutable arrays, field mutation, vector element mutation, option/result payload mutation, enum payload mutation, imports, runtime names, or stable ABI/layout. Current exp-113 fixture support: - `examples/supported/local-variables.slo` - `examples/formatter/local-variables.slo` - direct mutable `var` locals declared as `bool`, `i64`, and `f64` - same-type `set` reassignment from already promoted scalar expressions for those declared local types - the fixture pair retains the earlier direct `i32` local flow and exp-112 immutable `bool` local coverage This is a released experimental exp-113 fixture alignment. It does not claim beta maturity or add mutable `string` locals, vector mutation, option/result mutation, struct or enum mutation, mixed-type assignment, imports, runtime names, or stable ABI/layout. Current exp-20 fixture support: - `examples/supported/f64-numeric-primitive.slo` - `examples/formatter/f64-numeric-primitive.slo` - direct `f64` function parameters and returns - immutable `let` locals declared as `f64` - calls passing and returning `f64` - decimal `f64` literals in `f64` contexts - same-type `f64` `+`, `-`, `*`, `/`, `=`, `<`, `>`, `<=`, and `>=` - `std.io.print_f64` - top-level tests and `main` returning `i32` This is a released experimental exp-20 fixture. It does not claim beta maturity or widen `f32`, wider/common integer types, char/bytes/decimal, numeric casts, mixed numeric arithmetic, f64 collections, f64 enum payloads, f64 struct fields, parsing, random floats, broader math APIs, manifest schema, or stable ABI/layout. Current exp-21 fixture support: - `examples/supported/i64-numeric-primitive.slo` - `examples/formatter/i64-numeric-primitive.slo` - direct `i64` function parameters and returns - immutable `let` locals declared as `i64` - calls passing and returning `i64` - explicit signed decimal `i64` literal atoms with the `i64` suffix - same-type `i64` `+`, `-`, `*`, `/`, `=`, `<`, `>`, `<=`, and `>=` - `std.io.print_i64` - top-level tests and `main` returning `i32` This is a released experimental exp-21 fixture. It does not claim beta maturity or widen `f32`, unsigned integers, narrower integer widths, char/bytes/decimal, numeric casts, implicit promotion, mixed `i32`/`i64`/`f64` arithmetic, i64 collections, i64 enum payloads, i64 struct fields, parsing, random `i64`, broader math APIs, manifest schema, or stable ABI/layout. Current exp-22 fixture support: - `examples/supported/numeric-widening-conversions.slo` - `examples/formatter/numeric-widening-conversions.slo` - `std.num.i32_to_i64 : (i32) -> i64` - `std.num.i32_to_f64 : (i32) -> f64` - `std.num.i64_to_f64 : (i64) -> f64` - converted values feeding same-type arithmetic and comparison - top-level tests and `main` returning `i32` This is a released experimental alpha exp-22 fixture. It does not claim beta maturity or add implicit promotion, mixed numeric operators, narrowing or checked conversions, cast syntax, `f32`, unsigned or narrower integer families, numeric parse/format APIs, stable ABI/layout, manifest schema, or standard-library breadth. Current exp-23 fixture support: - `examples/supported/checked-i64-to-i32-conversion.slo` - `examples/formatter/checked-i64-to-i32-conversion.slo` - `std.num.i64_to_i32_result : (i64) -> (result i32 i32)` - `ok` results for signed `i32` range values - `err 1` results for out-of-range values, without range-failure traps - existing `std.result.*` observers and unwraps - top-level tests and `main` returning `i32` This is a released experimental alpha exp-23 fixture. It does not claim beta maturity or add `f64` narrowing, checked cast generics, mixed numeric operators, `std.num.cast`, unsigned or narrower integer families, numeric parse/format APIs, stable ABI/layout, manifest schema, or standard-library breadth. Current exp-25 fixture support: - `examples/supported/string-parse-i64-result.slo` - `examples/formatter/string-parse-i64-result.slo` - `std.string.parse_i64_result : (string) -> (result i64 i32)` - complete non-empty ASCII signed decimal `i64` parsing with optional leading `-` - success as `ok value` and parse/range failure as `err 1` - existing result observation/extraction helpers over `(result i64 i32)` - top-level tests and `main` returning `i32` This is a released experimental alpha exp-25 fixture. It does not claim beta maturity or add `f64` parse, generic parse, leading `+`, whitespace trimming, underscores, base/radix prefixes, locale-aware parsing, Unicode digit parsing, rich parse errors, stable ABI/layout/ownership, manifest schema, or standard-library breadth. Current exp-26 fixture support: - `examples/supported/f64-to-string.slo` - `examples/formatter/f64-to-string.slo` - `std.num.f64_to_string : (f64) -> string` - finite decimal ASCII text for promoted finite `f64` values - existing string equality, `std.string.len`, and `std.io.print_string` - top-level tests and `main` returning `i32` This is a released experimental alpha exp-26 fixture. It does not claim beta maturity or add `f32`, `f64` parse, generic format/display/interpolation, locale/base/radix/grouping/padding/precision controls, stable NaN/infinity text, implicit conversion, stable ABI/layout/ownership, manifest schema, or standard-library breadth. Current exp-27 fixture support: - `examples/supported/f64-to-i32-result.slo` - `examples/formatter/f64-to-i32-result.slo` - `std.num.f64_to_i32_result : (f64) -> (result i32 i32)` - `ok value` only for finite, exactly integral `f64` inputs inside the signed `i32` range - `err 1` for non-finite, fractional, or out-of-range input - existing result observation/extraction helpers over `(result i32 i32)` - top-level tests and `main` returning `i32` This is a released experimental alpha exp-27 fixture. It does not claim beta maturity or add unchecked `f64` to `i32`, casts or cast syntax, generic `cast_checked`, `f32`, unsigned or narrower integer families, `f64` parse, mixed numeric arithmetic, numeric containers, stable ABI/layout/ownership, manifest schema, or standard-library breadth. Current exp-28 fixture support: - `examples/supported/string-parse-f64-result.slo` - `examples/formatter/string-parse-f64-result.slo` - `std.string.parse_f64_result : (string) -> (result f64 i32)` - complete finite ASCII decimal `f64` parsing - `ok value` for `12.5` and `-0.25` - `err 1` for ordinary parse failure, non-finite text, trailing or leading unsupported characters, or out-of-domain input - existing result observation/extraction helpers over `(result f64 i32)` - top-level tests and `main` returning `i32` This is a released experimental alpha exp-28 fixture. It does not claim beta maturity or add generic parse, bool/string/bytes parse, locale parsing, Unicode digit parsing, underscores, rich parse errors, stable helper ABI/layout/ownership, result genericity, f64 containers, mixed numeric arithmetic, manifest schema, or standard-library breadth. Current exp-29 fixture support: - `examples/supported/numeric-struct-fields.slo` - `examples/formatter/numeric-struct-fields.slo` - direct immutable struct fields whose field types are exactly `i64` or `f64` - constructors with `i64` and finite `f64` field initializers - immutable struct local/parameter/return/call flow - field access returning `i64` or `f64` - existing same-type numeric arithmetic/comparison after field access - existing numeric print/format helpers after field access - top-level tests and `main` returning `i32` This is a released experimental alpha exp-29 fixture. It does not claim beta maturity or add struct field mutation, nested structs, arrays/vectors/options/results as fields, enum payload widening, numeric containers, `f32`, unsigned or narrower integer families, mixed numeric arithmetic, implicit conversions, new parse/format APIs, generic structs, methods, traits, stable ABI/layout/ownership, manifest schema, FFI layout claims, or standard-library breadth. Current exp-30 source-layout support: - `std/README.md` - `std/cli.slo` - `std/io.slo` - `std/string.slo` - `std/num.slo` - `std/result.slo` - `std/math.slo` - `examples/formatter/std-source-layout-alpha.slo` - flat current module names inside `std/*.slo` while repo-root `std` import/search remains deferred - source-authored `std/math.slo` helpers: `abs_i32`, `min_i32`, `max_i32`, `clamp_i32`, `square_i32`, and `square_f64` This is a released experimental alpha exp-30 source-layout fixture. It does not claim beta maturity or add automatic standard-library imports, replacement of compiler-known `std.*` calls, new compiler-known `std.*` operation names, stable standard-library APIs, manifest schema changes, broad math, generics, traits, overloads, module/package registry behavior, or stable ABI/layout. Current exp-31 fixture support: - `examples/supported/f64-to-i64-result.slo` - `examples/formatter/f64-to-i64-result.slo` - `std.num.f64_to_i64_result : (f64) -> (result i64 i32)` - `ok value` only for finite, exactly integral `f64` inputs inside the signed `i64` range - `err 1` for non-finite, fractional, or out-of-range input - formatter-stable conservative out-of-range fixture value `9223372036854776000.0` - existing result observation/extraction helpers over `(result i64 i32)` - `std.num.i64_to_string` over a successful `i64` payload - top-level tests and `main` returning `i32` This is a released experimental alpha exp-31 fixture. It does not claim beta maturity or add unchecked casts, unchecked `f64` to `i64`, cast syntax, generic `cast_checked`, `f32`, unsigned or narrower integer families, mixed numeric arithmetic, broad math, numeric containers, stable ABI/layout/ ownership, manifest schema changes, or standard-library breadth. Detailed edge behavior around the `f64`/`i64` limits is implementation-owned Glagol test coverage. Current exp-32 source-helper support: - `std/math.slo` - retained exp-30 helpers: `abs_i32`, `min_i32`, `max_i32`, `clamp_i32`, `square_i32`, and `square_f64` - added `i64` helpers: `abs_i64`, `min_i64`, `max_i64`, `clamp_i64`, and `square_i64` - added finite `f64` helpers: `abs_f64`, `min_f64`, `max_f64`, and `clamp_f64` - ordinary source functions using existing same-type arithmetic/comparison, `if`, literals, calls, and explicit signatures This is a released experimental alpha exp-32 source fixture. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded `std/` source, new compiler-known `std.*` operation names, broad math, trigonometry, `sqrt`, `pow`, `f32`, unsigned or narrower integer families, generic math, overloads, traits, mixed numeric arithmetic, numeric containers, stable ABI/layout/ownership, manifest schema changes, or standard-library breadth. Current exp-33 source-helper support: - `std/result.slo` - retained i32 helpers: `is_ok_i32`, `is_err_i32`, `unwrap_ok_i32`, and `unwrap_err_i32` - completed concrete err wrappers: `is_err_i64`, `unwrap_err_i64`, `is_err_string`, `unwrap_err_string`, `is_err_f64`, and `unwrap_err_f64` - concrete fallback helpers: `unwrap_or_i32`, `unwrap_or_i64`, `unwrap_or_string`, and `unwrap_or_f64` - ordinary source functions over existing `std.result.is_ok`, `std.result.is_err`, `std.result.unwrap_ok`, `std.result.unwrap_err`, `if`, `match`, parameters, and explicit signatures This is a released experimental alpha exp-33 source fixture. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded `std/` source, new compiler-known `std.*` operation names, generic `std.result.map`, generic `std.result.unwrap_or`, `std.result.and_then`, option helper names, new result payload families, stable ABI/layout/ ownership, manifest schema changes, or standard-library breadth. Current exp-34 fixture support: - `examples/supported/string-parse-bool-result.slo` - `examples/formatter/string-parse-bool-result.slo` - `std.string.parse_bool_result : (string) -> (result bool i32)` - exact complete ASCII lowercase `true` and `false` parsing - `ok true` for `true` - `ok false` for `false` - `err 1` for empty input, uppercase or mixed-case text, leading or trailing whitespace, numeric text, and any other text - existing result observation/extraction helpers over the returned `(result bool i32)` value - top-level tests and `main` returning `i32` This is a released experimental alpha exp-34 fixture. It does not claim beta maturity or add generic parse APIs, trap-based parse, bool parsing beyond exact lowercase `true`/`false`, string/bytes parse, whitespace trimming, case-insensitive parsing, locale/Unicode parsing, numeric boolean parsing, rich parse errors, source-authored `std/result.slo` bool wrappers, stable helper ABI/layout/ownership, manifest schema changes, or standard-library breadth. Current exp-35 source-helper support: - `std/result.slo` - retained exp-33 concrete result source helpers - added `(result bool i32)` helpers: `is_ok_bool`, `is_err_bool`, `unwrap_ok_bool`, `unwrap_err_bool`, and `unwrap_or_bool` - ordinary source functions over existing compiler-supported `std.result.is_ok`, `std.result.is_err`, `std.result.unwrap_ok`, `std.result.unwrap_err`, `if`, parameters, and explicit signatures - alignment with exp-34 compiler-supported bool parse result fixture flow This is a released experimental alpha exp-35 source fixture. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded `std/` source, new compiler-known `std.*` operation names, source-authored generic result helpers, generic `std.result.map`, generic `std.result.unwrap_or`, `std.result.and_then`, option helper names, source constructors for `(result bool i32)`, general source `match` over `(result bool i32)` beyond compiler-supported fixture flow, stable ABI/layout/ownership, manifest schema changes, or standard-library breadth. Current exp-74/exp-109 source-helper support: - `std/result.slo` - retained exp-33 and exp-35 concrete result source helpers - concrete source constructors: `ok_i32`, `err_i32`, `ok_i64`, `err_i64`, `ok_string`, `err_string`, `ok_f64`, `err_f64`, `ok_bool`, and `err_bool` - concrete bridge helpers: `ok_or_none_i32`, `ok_or_none_i64`, `ok_or_none_string`, `ok_or_none_f64`, and `ok_or_none_bool` - ordinary source functions over existing compiler-supported `ok`, `err`, `std.result.is_ok`, `std.result.unwrap_ok`, `some`, `none`, `if`, `match`, parameters, and explicit signatures This is the released experimental alpha result helper family through exp-109. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded `std/` source, new compiler-known `std.*` operation names, generic result helpers, broader `map`/`and_then`/`transpose`/`flatten` packages, new payload families, stable ABI/layout/ownership, manifest schema changes, or standard-library breadth. Current exp-36/exp-75/exp-95/exp-100/exp-102/exp-109 source-helper support: - `std/option.slo` - concrete `(option i32)` helpers: `some_i32`, `none_i32`, `is_some_i32`, `is_none_i32`, `unwrap_some_i32`, `unwrap_or_i32`, and `some_or_err_i32` - concrete `(option i64)` helpers: `some_i64`, `none_i64`, `is_some_i64`, `is_none_i64`, `unwrap_some_i64`, `unwrap_or_i64`, and `some_or_err_i64` - concrete `(option f64)` helpers: `some_f64`, `none_f64`, `is_some_f64`, `is_none_f64`, `unwrap_some_f64`, `unwrap_or_f64`, and `some_or_err_f64` - concrete `(option bool)` helpers: `some_bool`, `none_bool`, `is_some_bool`, `is_none_bool`, `unwrap_some_bool`, `unwrap_or_bool`, and `some_or_err_bool` - concrete `(option string)` helpers: `some_string`, `none_string`, `is_some_string`, `is_none_string`, `unwrap_some_string`, `unwrap_or_string`, and `some_or_err_string` - ordinary source functions over existing compiler-supported `is_some`, `is_none`, `unwrap_some`, `ok`, `err`, `if`, parameters, and explicit signatures - flat `std/*.slo` facade organization, with any future `std.slo` aggregator/reexport layer deferred until import/search semantics exist This is the released experimental alpha option helper family through exp-109. It does not claim beta maturity or add automatic standard-library imports, repo-root `std/` search, compiler-loaded `std/` source, new compiler-known `std.*` operation names, generic option helpers, option payload families beyond `(option i32)`, `(option i64)`, `(option f64)`, `(option bool)`, and `(option string)`, stable ABI/layout/ownership, manifest schema changes, or standard-library breadth. Current exp-111 stdlib/source support: - `std/io.slo` retains the zero-returning and value-returning print wrappers and now also adds `read_stdin_result`, `read_stdin_option`, `read_stdin_or`, `read_stdin_i32_result`, `read_stdin_i32_option`, `read_stdin_i32_or_zero`, `read_stdin_i32_or`, `read_stdin_i64_result`, `read_stdin_i64_option`, `read_stdin_i64_or_zero`, `read_stdin_i64_or`, `read_stdin_f64_result`, `read_stdin_f64_option`, `read_stdin_f64_or_zero`, `read_stdin_f64_or`, `read_stdin_bool_result`, `read_stdin_bool_option`, `read_stdin_bool_or_false`, and `read_stdin_bool_or` - the matching explicit import fixture `examples/projects/std-import-io/` now imports the expanded helper list and keeps stdin assertions structural so the runner does not need to provide a specific stdin payload - all new helpers are ordinary source wrappers over the promoted `std.io.read_stdin_result`, `std.string.parse_*_result`, and exp-109 `std.result.ok_or_none_*` Current exp-110 stdlib/source support: - `std/string.slo` retains `len`, `concat`, the concrete `parse_*_result` wrappers, the zero/custom-fallback helpers, and now also adds `parse_i32_option`, `parse_i64_option`, `parse_f64_option`, and `parse_bool_option` - `std/env.slo` retains `get`, `get_result`, `has`, `get_or`, the typed `*_result` and fallback helpers, and now also adds `get_option`, `get_i32_option`, `get_i64_option`, `get_f64_option`, and `get_bool_option` - `std/fs.slo` retains text read/write helpers, the typed `*_result` and fallback helpers, and now also adds `read_text_option`, `read_i32_option`, `read_i64_option`, `read_f64_option`, and `read_bool_option` - `std/process.slo` retains `argc`, `arg`, `arg_result`, `has_arg`, `arg_or`, `arg_or_empty`, the typed `*_result` and fallback helpers, and now also adds `arg_option`, `arg_i32_option`, `arg_i64_option`, `arg_f64_option`, and `arg_bool_option` - `std/cli.slo` retains `arg_text_result`, the typed `*_result` and fallback helpers, and now also adds `arg_text_option`, `arg_i32_option`, `arg_i64_option`, `arg_f64_option`, and `arg_bool_option` - all new helpers are ordinary source wrappers over existing concrete result helpers through exp-109 `std.result.ok_or_none_*` - the matching explicit import fixtures `examples/projects/std-import-string/`, `examples/projects/std-import-env/`, `examples/projects/std-import-fs/`, `examples/projects/std-import-process/`, and `examples/projects/std-import-cli/` now import the expanded helper lists and keep deterministic option/result and fallback coverage This is the current released exp-111 stdlib/source contract summary, with the immediately previous exp-110 source package still listed above. It does not claim beta maturity or add compiler-known std names, generics, new runtime calls beyond the already promoted stdin-result lane, line/binary/async stdin APIs, vec work, stable ABI/layout/ownership, or optimizer guarantees. Current exp-125 Slovo-side target: - `std/result.slo` stages concrete `(result u32 i32)` and `(result u64 i32)` constructor, observer, unwrap, fallback, and option-bridge helpers - `std/option.slo` stages concrete `(option u32)` and `(option u64)` constructor, observer, unwrap, fallback, and result-bridge helpers - `std/string.slo` stages `parse_u32_*` and `parse_u64_*` result/option/ fallback helper lanes - `std/num.slo` stages `u32_to_string` and `u64_to_string` - `std/io.slo`, `std/env.slo`, `std/fs.slo`, `std/process.slo`, and `std/cli.slo` stage matching `u32`/`u64` helper parity over the concrete family pattern already used for `i32`, `i64`, `f64`, `bool`, and `string` - the matching Slovo fixtures are `u32-numeric-primitive.slo`, `u64-numeric-primitive.slo`, `unsigned-integer-to-string.slo`, `string-parse-u32-result.slo`, `string-parse-u64-result.slo`, and the widened `examples/projects/std-import-*` module fixtures This is a current Slovo-side contract target only. It does not claim beta maturity, released compiler support, implicit promotion, mixed signed/unsigned arithmetic, broader cast families, unsigned widths beyond `u32`/`u64`, or stable ABI/layout/ownership. Current exp-37 source-facade support: - `std/time.slo` - narrow time wrappers: `monotonic_ms` and `sleep_ms_zero` - ordinary source functions over existing compiler-supported `std.time.monotonic_ms`, `std.time.sleep_ms`, parameters, sequential body forms, and explicit signatures - flat `std/*.slo` facade organization, with any future `std.slo` aggregator/reexport layer deferred until import/search semantics exist This is a released experimental alpha exp-37 source fixture. It does not claim beta maturity or add automatic standard-library imports, repo-root `std/` search, compiler-loaded `std/` source, new compiler-known `std.*` operation names, wall-clock/calendar/timezone APIs, high-resolution timers, async timers, cancellation, scheduling guarantees, stable ABI/layout/ownership, manifest schema changes, or standard-library breadth. Current exp-38 source-facade support: - `std/random.slo` - `std/env.slo` - `std/fs.slo` - narrow host/runtime wrappers for `std.random.i32`, `std.env.get`, `std.env.get_result`, `std.fs.read_text`, `std.fs.read_text_result`, `std.fs.write_text`, and `std.fs.write_text_result` - flat `std/*.slo` facade organization, with any future `std.slo` aggregator/reexport layer deferred until import/search semantics exist This is a released experimental alpha exp-38 source fixture. It does not claim beta maturity or add automatic standard-library imports, repo-root `std/` search, compiler-loaded `std/` source, new compiler-known `std.*` operation names, random seed/range/bytes/float/UUID/crypto APIs, environment mutation/enumeration, rich host error ADTs, binary/directory/streaming/async filesystem APIs, stable ABI/layout/ownership, manifest schema changes, or standard-library breadth. Current exp-39 source-helper support: - `std/math.slo` - retained exp-32 helpers: `abs`, `min`, `max`, `clamp`, and `square` for the currently staged `i32`, `i64`, and finite `f64` families - added helpers for each family: `neg`, `cube`, `is_zero`, `is_positive`, `is_negative`, and inclusive `in_range` - ordinary source functions using existing same-type arithmetic/comparison, `if`, literals, calls, and explicit signatures - matching Glagol benchmark scaffold gates for local `math-loop` timing comparisons only, with no performance threshold in the language contract This is a released experimental alpha exp-39 source fixture. It does not claim beta maturity or add automatic standard-library imports, repo-root `std/` search, compiler-loaded `std/` source, new compiler-known `std.*` operation names, trigonometry, `sqrt`, `pow`, modulo, bit operations, generic math, overloads, traits, mixed numeric arithmetic, optimizer guarantees, benchmark thresholds, stable ABI/layout/ownership, manifest schema changes, or standard-library breadth. Current exp-40 governance/tooling support: - project licensing recorded as `MIT OR Apache-2.0` - release naming criteria documented in `.llm/ALPHA_BETA_RELEASE_CRITERIA.md` - Glagol benchmark-suite gates aligned for `math-loop`, `branch-loop`, `parse-loop`, `array-index-loop`, `string-eq-loop`, `array-struct-field-loop`, and `enum-struct-payload-loop` - Slovo, C, Rust, Python, and Clojure benchmark source slots, with local-only timing comparisons and no release threshold; Common Lisp/SBCL is also part of the current paired benchmark publication surface This is a released experimental alpha exp-40 governance/tooling fixture. It does not claim beta maturity or add source syntax, type forms, standard-library APIs, optimizer guarantees, benchmark thresholds, cross-machine performance claims, stable ABI/layout/ownership, package registry behavior, or language-surface changes. Current exp-41 governance/tooling support: - Glagol benchmark-suite gates include Common Lisp/SBCL beside Clojure as a second Lisp-family comparison target - benchmark timing is explicitly cold-process local-machine evidence only - Clojure timings include JVM and Clojure startup; Common Lisp timings include SBCL script startup - the current published benchmark-suite kernel inventory is `math-loop`, `branch-loop`, `parse-loop`, `array-index-loop`, `string-eq-loop`, `array-struct-field-loop`, and `enum-struct-payload-loop` This is a released experimental alpha exp-41 governance/tooling fixture. It does not claim beta maturity or add source syntax, type forms, standard-library APIs, optimizer guarantees, benchmark thresholds, cross-machine performance claims, stable ABI/layout/ownership, package registry behavior, or language-surface changes. Current exp-42 governance/tooling support: - Glagol benchmark-suite gates separate `cold-process` and `hot-loop` timing modes - hot-loop mode uses a larger runtime-supplied loop count and reports total time plus normalized median time for the base loop count - the paired benchmark-suite kernel inventory now covers arithmetic, branching, parsing, checked fixed-array indexing, exact string equality, direct fixed-array struct-field access, and unary enum payload matching over non-recursive struct payloads - Slovo language surface remains unchanged; no high-resolution timing API is promoted This is a released experimental alpha exp-42 governance/tooling fixture. It does not claim beta maturity or add source syntax, type forms, standard-library APIs, high-resolution timing APIs, optimizer guarantees, benchmark thresholds, cross-machine performance claims, stable ABI/layout/ownership, package registry behavior, or language-surface changes. Current exp-43 documentation/tooling support: - `docs/SLOVO_WHITEPAPER.md` records the current language state, Lisp-family comparison, local benchmark evidence, and path to `1.0.0-beta` - generated PDF artifacts publish the whitepaper and language manifest - `.llm/skills/slovo-beta-language-design/SKILL.md` records the manifest-first beta language-design workflow This is a released experimental alpha exp-43 documentation/tooling fixture. It does not claim beta maturity or add source syntax, type forms, standard-library APIs, optimizer guarantees, benchmark thresholds, cross-machine performance claims, stable ABI/layout/ownership, package registry behavior, or language-surface changes. Current exp-44 language/tooling support: - `std/math.slo` carries its own export list for helper imports - `examples/projects/std-import-math/` imports `(import std.math (...))` without a local copied `math.slo` - Glagol resolves explicit project-mode `std.math` imports to the repo-root standard-library source file This is a released experimental alpha exp-44 source-search fixture. It does not claim beta maturity or add automatic standard-library imports, broad standard-library APIs, package registry behavior, workspace/package std imports, optimizer guarantees, stable ABI/layout/ownership, or a `std.slo` aggregator. Current exp-45 language/tooling support: - `std/result.slo` and `std/option.slo` carry their own export lists - `examples/projects/std-import-result/` imports `(import std.result (...))` without a local copied `result.slo` - `examples/projects/std-import-option/` imports `(import std.option (...))` without a local copied `option.slo` - Glagol resolves these explicit project-mode imports to the repo-root standard-library source files This is a released experimental alpha exp-45 source-search fixture. It does not claim beta maturity or add automatic standard-library imports, generic result or option helpers, broad standard-library APIs, package registry behavior, workspace/package std imports, optimizer guarantees, stable ABI/layout/ownership, or a `std.slo` aggregator. Current exp-46 language/tooling support: - `examples/workspaces/std-import-option/` imports `(import std.option (...))` from a workspace package without a local copied `option.slo` - Glagol resolves explicit workspace-package `std.` 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 `, `glagol fmt `, `glagol test `, and `glagol build -o `. - 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 [--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 ` remains stdout formatting. - `glagol fmt --check ` checks canonical formatting without writing files. - `glagol fmt --write ` writes canonical formatting for one file or all immediate project source modules. - `glagol doc -o ` 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 --filter ` plus legacy `glagol --run-tests --filter ` 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 current v1 machine diagnostic schema, with beta policy and catalog details in [`docs/language/DIAGNOSTICS.md`](DIAGNOSTICS.md). - [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 [--name ]` as a non-overwriting v1.3-style project scaffold command. - [x] Preserve plain `glagol fmt ` as stdout formatting. - [x] Define `glagol fmt --check ` as non-writing canonical formatting verification. - [x] Define `glagol fmt --write ` as in-place canonical formatting for one file or immediate project source modules. - [x] Define `glagol doc -o ` 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.