# Slovo Release Notes

## Release Maturity Policy

Historical `exp-*` releases listed here are experimental maturity milestones.
`1.0.0-beta` is the first real general-purpose beta release.

The pushed tag `v2.0.0-beta.1` is historical. It is now documented as an
experimental integration/readiness release, not as a beta maturity claim.

The current release is `1.0.0-beta.12`, published on 2026-05-22. It keeps the
`1.0.0-beta` language surface, includes the first post-beta tooling/install
hardening bundle from `1.0.0-beta.1`, and adds the first runtime/resource
foundation bundle from `1.0.0-beta.2` plus the first standard-library
stabilization bundle from `1.0.0-beta.3`, the first language-usability
diagnostics bundle from `1.0.0-beta.4`, and the first local
package/workspace discipline bundle from `1.0.0-beta.5`, plus the first
loopback networking foundation bundle from `1.0.0-beta.6`, and the first
serialization/data-interchange foundation bundle from `1.0.0-beta.7`, and the
first concrete type alias foundation from `1.0.0-beta.8`, plus the first
collection alias unification and generic reservation slice from
`1.0.0-beta.9`, the first developer-experience API discovery slice from
`1.0.0-beta.10`, and the local package API documentation extension from
`1.0.0-beta.11`, plus the concrete vector query and prefix parity slice from
`1.0.0-beta.12`.

## Unreleased

No unreleased language scope is committed here yet.

## 1.0.0-beta.12

Release label: `1.0.0-beta.12`

Release name: Concrete Vector Query And Prefix Parity

Release date: 2026-05-22

Status: released beta stdlib/helper parity update on the `1.0.0-beta`
language baseline.

`1.0.0-beta.12` is a source-authored concrete vector helper release. It closes
small parity gaps in the current concrete vector facades without changing the
language, typed core, runtime, ABI, or compiler-known `std.vec.*` runtime
names:

- `std.vec_i64` gains `count_of`, `starts_with`, `without_prefix`,
  `ends_with`, and `without_suffix`.
- `std.vec_f64` gains `count_of`.
- The helper behavior stays source-authored over the existing concrete vector
  runtime names, current equality, `len`, `at`, `take`, `drop`, and recursive
  helper style.
- Focused Glagol fixture coverage exercises repeated `count_of` results and
  prefix/suffix empty, mismatch, exact, and longer-than-input cases where the
  helper family applies.

This release does not add executable generics, maps, sets, iterators, mutable
vectors, slice/view APIs, new runtime names, new compiler-known stdlib names,
ABI/layout stability, performance claims, stable stdlib API freeze, generic
stdlib dispatch, or broad collection abstractions.

## 1.0.0-beta.11

Release label: `1.0.0-beta.11`

Release name: Local Package API Documentation

Release date: 2026-05-22

Status: released beta documentation/API-discovery update on the
`1.0.0-beta` language baseline.

`1.0.0-beta.11` extends the beta.10 API discovery lane from the generated
standard-library catalog and `glagol symbols` metadata into local package and
module documentation:

- `glagol doc <file|project|workspace> -o <dir>` includes deterministic
  exported/public API sections for local source files, projects, packages, and
  workspaces.
- Public API sections list exact exported function signatures, exported struct
  fields, and exported enum variants with payload types.
- Module-local concrete aliases are normalized before public rendering, so
  local names do not leak into package/module API docs.
- Non-exported functions, structs, enums, tests, and `(type ...)` aliases
  remain omitted from the public API surface.

This release does not define a stable Markdown schema, stable stdlib/API
compatibility freeze, LSP server, watch mode, SARIF, daemon protocols,
diagnostics schema policy, executable generics, maps, sets, re-exports, globs,
hierarchical modules, package registry semantics, runtime changes, new
compiler-known runtime names, or stable ABI/layout promises.

## 1.0.0-beta.10

Release label: `1.0.0-beta.10`

Release name: Developer Experience API Discovery

Release date: 2026-05-22

Status: released beta documentation/API-discovery update on the
`1.0.0-beta` language baseline.

`1.0.0-beta.10` upgrades `docs/language/STDLIB_API.md` from an exported-name
index to a generated exported-signature catalog and adds an editor-facing
symbol metadata command:

- `scripts/render-stdlib-api-doc.js` parses each `lib/std/*.slo` module,
  validates that exported helpers have matching `(fn ...)` forms, and renders
  their public parameter and return types.
- Module-local concrete aliases introduced in beta.8 and used across beta.9
  collection/value-family facades are normalized before rendering, so public
  signatures show concrete types such as `(vec i32)`, `(option string)`, and
  `(result u64 i32)` instead of local names such as `VecI32` or `ResultU64`.
- Non-exported helper functions and `(type ...)` aliases remain omitted from
  the public catalog.
- `glagol symbols <file.slo|project|workspace>` emits deterministic
  `slovo.symbols` S-expression metadata for modules, imports, exports,
  aliases, structs, enums, functions, tests, source spans/ranges, and
  workspace package labels.

This release does not add executable generics, generic aliases,
parameterized aliases, maps, sets, traits, inference, monomorphization,
iterators, runtime changes, new compiler-known runtime names, stable
ABI/layout promises, an LSP server, watch mode, SARIF, daemon protocols, or a
stable standard-library API freeze.

## 1.0.0-beta.9

Release label: `1.0.0-beta.9`

Release name: Collection Alias Unification And Generic Reservation

Release date: 2026-05-22

Status: released beta collection-alias documentation/source update on the
`1.0.0-beta` language baseline.

`1.0.0-beta.9` applies beta.8 transparent concrete aliases sparingly inside
the source-authored collection and value-family facades:

- `std.vec_i32`, `std.vec_i64`, `std.vec_f64`, `std.vec_bool`, and
  `std.vec_string` name their local concrete vector family once and reuse that
  alias through helper signatures.
- `std.option` and `std.result` name the current concrete option/result helper
  families once and reuse those local aliases through their facade signatures.
- Public helper names, imports, exports, constructors, runtime calls, and
  behavior stay concrete. Cross-module users still see normalized concrete
  types such as `(vec bool)`, `(option string)`, and `(result u64 i32)`.

This release does not add executable generics, generic aliases, parameterized
aliases, maps, sets, traits, inference, monomorphization, iterators, new
compiler-known runtime names, stable ABI/layout promises, or a stable
standard-library API freeze. The generic/map/set direction is reserved for
future diagnostics and design work only.

## 1.0.0-beta.8

Release label: `1.0.0-beta.8`

Release name: Concrete Type Alias Foundation

Release date: 2026-05-22

Status: released beta concrete type alias foundation update on the
`1.0.0-beta` language baseline.

`1.0.0-beta.8` promotes transparent type aliases for current concrete types:

```slo
(type JsonText string)
```

An alias is a module-local source name. It may be used in supported type
positions, and the compiler resolves it to the existing concrete target type
before backend and ABI behavior. This release does not add generics,
parameterized aliases, cross-module alias imports, alias re-exports, maps/sets,
stable layout names, new compiler-known runtime names, or runtime changes.

- Top-level `(type Alias TargetType)` declarations name existing concrete
  supported target types without introducing new runtime representations.
- Aliases are transparent before typed-core lowering, checked import
  signatures, backend layout, ABI decisions, and runtime behavior.
- The JSON source facade and explicit JSON example projects use local
  `JsonText` / `JsonField` aliases as narrow source fixtures.
- Alias exports, imports, re-exports, cross-module alias visibility, generic
  aliases, parameterized aliases, maps/sets, and runtime changes remain out of
  scope.

## 1.0.0-beta.7

Release label: `1.0.0-beta.7`

Release name: Serialization And Data Interchange Bundle

Release date: 2026-05-22

Status: released beta serialization/data-interchange update on the
`1.0.0-beta` language baseline.

- `lib/std/json.slo` stages an explicit `std.json` source facade for compact
  JSON text construction.
- The facade wraps the compiler-known `std.json.quote_string` runtime helper
  and composes it with existing `std.string.concat` and `std.num.*_to_string`
  helpers for scalar values, fields, small arrays, and small objects.
- `examples/projects/std-import-json/` and
  `examples/projects/std-layout-local-json/` document the explicit import and
  local source facade shapes.
- `benchmarks/json-quote-loop/` adds a local-machine timing scaffold for JSON
  string quoting across Slovo, C, Rust, Python, Clojure, and Common Lisp/SBCL.

This release does not add JSON parsing, recursive JSON values, maps/sets,
generic collections, streaming encoders, schema validation, Unicode
normalization, stable text encoding policy beyond the current null-terminated
runtime string ABI, or a stable standard-library API freeze.

## 1.0.0-beta.6

Release label: `1.0.0-beta.6`

Release name: Networking Foundation Bundle

Release date: 2026-05-22

Status: released beta networking foundation update on the `1.0.0-beta`
language baseline.

- `lib/std/net.slo` stages an explicit `std.net` source facade for blocking
  loopback TCP only.
- The facade wraps the targeted compiler-known calls
  `std.net.tcp_connect_loopback_result`,
  `std.net.tcp_listen_loopback_result`, `std.net.tcp_bound_port_result`,
  `std.net.tcp_accept_result`, `std.net.tcp_read_all_result`,
  `std.net.tcp_write_text_result`, and `std.net.tcp_close_result`.
- `examples/projects/std-import-net/` and
  `examples/projects/std-layout-local-net/` document the explicit import and
  local source facade shapes using deterministic invalid port/handle result
  checks.

This release does not add DNS, TLS, async IO, UDP, non-loopback binding, HTTP
frameworks, stable socket ABI/layout, platform-specific error codes, rich
host-error ADTs, automatic ownership/finalization, or a stable standard-library
API freeze.

## 1.0.0-beta.5

Release label: `1.0.0-beta.5`

Release name: Package And Workspace Discipline Bundle

Release date: 2026-05-22

Status: released beta package/workspace update on the `1.0.0-beta` language
baseline.

`1.0.0-beta.5` tightens local workspace behavior without adding a package
manager:

- Local workspace manifests may now declare
  `[workspace] default_package = "name"` to make build/run entry selection
  deterministic when more than one package has an entry module.
- Duplicate workspace member paths after normalization are now a dedicated
  `DuplicateWorkspaceMember` diagnostic.
- Missing `default_package` references are now a dedicated
  `WorkspaceDefaultPackageMissing` diagnostic. A selected default package that
  lacks its configured entry module is diagnosed as
  `WorkspaceDefaultPackageEntryMissing` during build/run.
- Workspace documentation generated by `glagol doc` now includes a
  deterministic summary of members, packages, and local dependency edges.
- Generated workspace templates and the canonical local workspace examples now
  declare `default_package = "app"`.
- `docs/language/PACKAGES.md` now documents the beta local package/workspace
  rules and the explicit no-registry/no-lockfile policy.

This release does not add remote registries, lockfiles, semantic-version
solving, package publishing, optional/dev/target dependencies, feature flags,
build scripts, package archives, or stable package ABI/layout guarantees.

## 1.0.0-beta.4

Release label: `1.0.0-beta.4`

Release name: Language Usability Diagnostics Bundle

Release date: 2026-05-22

Status: released beta diagnostics usability update on the `1.0.0-beta`
language baseline.

`1.0.0-beta.4` improves diagnostics while keeping the accepted source-language
surface unchanged:

- project/workspace build and run entry failures now report entry-specific
  diagnostic codes and spell out the required `(fn main () -> i32 ...)`
  contract
- non-exhaustive `match` diagnostics now use clearer missing-arm wording and a
  deterministic found-arm list
- `.llm/BETA_4_LANGUAGE_USABILITY.md` records the beta.4 usability contract
  and deferrals

This release does not add new syntax, type aliases, argument-taking `main`,
`unit`-returning `main`, changed `match` semantics, or stable ABI/layout
guarantees.

## 1.0.0-beta.3

Release label: `1.0.0-beta.3`

Release name: Standard Library Stabilization Bundle

Release date: 2026-05-22

Status: released beta standard-library stabilization update on the
`1.0.0-beta` language baseline.

`1.0.0-beta.3` contains the first standard-library stabilization slice:

- `docs/language/STDLIB_API.md` is generated from the exported helpers in
  `lib/std/*.slo`
- `scripts/render-stdlib-api-doc.sh` regenerates that catalog, and
  `scripts/release-gate.sh` fails if the generated catalog is stale
- `examples/projects/stdlib-composition` adds a realistic command-line project
  that composes explicit `std.fs`, `std.string`, `std.math`, and `std.io`
  imports for file write/read, parse, compute, cleanup, and hosted run output
- `.llm/BETA_3_STDLIB_STABILIZATION.md` records the beta.3 stabilization
  contract and deferred decisions

This release does not freeze stable standard-library APIs. It still defers
generics, an automatic prelude, stable ABI/layout guarantees, richer host error
codes, maps/sets, networking, and async behavior.

## 1.0.0-beta.2

Release label: `1.0.0-beta.2`

Release name: Runtime Resource Foundation Bundle

Release date: 2026-05-22

Status: released beta runtime/resource foundation update on the `1.0.0-beta`
language baseline.

`1.0.0-beta.2` contains the first runtime/resource foundation slice:

- `std.fs.open_text_read_result : (string) -> (result i32 i32)` opens a
  read-only text file and returns an opaque positive `i32` handle
- `std.fs.read_open_text_result : (i32) -> (result string i32)` reads remaining
  text from an open read handle
- `std.fs.close_result : (i32) -> (result i32 i32)` closes an open handle
- `std.fs.exists : (string) -> bool`, `std.fs.is_file : (string) -> bool`,
  and `std.fs.is_dir : (string) -> bool` expose narrow filesystem status
  checks
- `std.fs.remove_file_result : (string) -> (result i32 i32)` removes a file
  and `std.fs.create_dir_result : (string) -> (result i32 i32)` creates one
  directory, both returning `ok 0` or `err 1`
- `lib/std/fs.slo` wraps those calls with explicit source facades
  `open_text_read_result`, `read_open_text_result`, `close_result`,
  `read_text_via_handle_result`, `close_ok`, status helpers, and narrow
  file/directory mutation helpers

This release keeps handles beta-scoped. It does not add writable handles,
binary IO, directory handles, directory enumeration, recursive filesystem
operations, process handles, sockets, async IO, platform error codes, rich
host-error ADTs, or stable handle ABI/layout promises.

## 1.0.0-beta.1

Release label: `1.0.0-beta.1`

Release name: First Post-Beta Tooling Hardening Bundle

Release date: 2026-05-22

Status: released beta tooling update on the `1.0.0-beta` language baseline.

`1.0.0-beta.1` contains tooling hardening only:

- `glagol run <file.slo|project>` builds and executes through the hosted native
  toolchain using `.slovo/build` when `-o` is not provided
- `glagol clean <file.slo|project>` removes generated `.slovo/build` artifacts
- `glagol new --template binary|library|workspace` scaffolds binary projects,
  library projects, and local package workspaces using existing manifest rules
- `scripts/install.sh` installs the compiler, `lib/std`, and runtime C input
  under a configurable prefix
- installed `glagol` discovers `share/slovo/std` and
  `share/slovo/runtime/runtime.c` relative to its executable, with environment
  overrides still available
- the release gate prints a concise final success line after all checks pass

This beta.1 slice does not add source-language syntax, stable ABI/layout
guarantees, networking, package registry behavior, or a stable standard-library
freeze.

## 1.0.0-beta

Release label: `1.0.0-beta`

Release name: First Real General-Purpose Beta

Release date: 2026-05-21

Status: released beta language contract.

The normative Slovo-side beta contract is `.llm/V1_0_0_BETA.md`.

`1.0.0-beta` includes:

- `i32`, `i64`, `u32`, `u64`, `f64`, `bool`, and `string`
- current fixed immutable arrays, current concrete vector families, structs,
  enums, option/result, and lexical `unsafe` gating
- explicit `std/*.slo` imports for strings, numerics, IO, CLI, process args,
  env, text FS, time, randomness, result/option, and concrete vectors
- local packages, workspaces, deterministic dependency handling, generated
  docs, formatter modes, JSON diagnostics, and the paired local release gate

`1.0.0-beta` still defers generics, maps/sets, remote registries,
networking/async, and stable ABI/layout/ownership guarantees.

## exp-125 (final experimental precursor scope)

Release label: `exp-125`

Release name: Unsigned U32 U64 Numeric And Stdlib Breadth Alpha

Target date: 2026-05-21

Status: completed experimental precursor scope absorbed into `1.0.0-beta`.

The normative Slovo-side contract target is
`.llm/EXP_125_UNSIGNED_U32_U64_NUMERIC_AND_STDLIB_BREADTH_ALPHA.md`.

exp-125 broadens the numeric and staged stdlib surface with one connected
unsigned scope:

- direct `u32` and `u64` value flow
- decimal suffixed literals `42u32` and `42u64`
- same-type unsigned arithmetic and comparison
- compiler-known `std.io.print_u32`, `std.io.print_u64`,
  `std.num.u32_to_string`, `std.num.u64_to_string`,
  `std.string.parse_u32_result`, and `std.string.parse_u64_result`
- source helper parity across `std.result`, `std.option`, `std.string`,
  `std.num`, `std.io`, `std.env`, `std.fs`, `std.process`, and `std.cli`

The matching Slovo-side fixtures include
`examples/supported/u32-numeric-primitive.slo`,
`examples/supported/u64-numeric-primitive.slo`,
`examples/supported/unsigned-integer-to-string.slo`,
`examples/supported/string-parse-u32-result.slo`,
`examples/supported/string-parse-u64-result.slo`, their formatter mirrors,
and the widened explicit import fixtures under `examples/projects/std-import-*`.

exp-125 itself did not claim beta maturity, implicit numeric promotion, mixed
signed/unsigned arithmetic, broader cast families, unsigned widths beyond
`u32`/`u64`, generic numeric helpers, unsigned collections, unsigned enum
payloads or struct fields, stable ABI/layout/ownership, or released compiler
support before the sibling Glagol work landed.

## exp-124 (released experimental alpha)

Release label: `exp-124`

Release name: Fixed Array Enum And Struct Elements Alpha

Release date: 2026-05-21

Status: released experimental alpha language contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_124_FIXED_ARRAY_ENUM_AND_STRUCT_ELEMENTS_ALPHA.md`.

exp-124 broadens the fixed immutable array surface with two connected element
lanes:

- direct known enum elements
- current known non-recursive struct elements

The release promotes immutable locals, parameters, returns, calls returning
arrays, and checked `i32` indexing over those new element families. It adds
`examples/supported/array-enum.slo`,
`examples/formatter/array-enum.slo`,
`examples/supported/array-struct-elements.slo`, and
`examples/formatter/array-struct-elements.slo`.

exp-124 does not add zero-length arrays, mutable arrays, element mutation,
array equality, array printing, nested arrays, slices, generics, stable
ABI/layout/ownership claims, or beta maturity.

## exp-123 (released experimental alpha)

Release label: `exp-123`

Release name: Owned Vector Benchmark Suite Extension And Whitepaper Refresh Alpha

Release date: 2026-05-21

Status: released experimental alpha documentation/tooling contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_123_OWNED_VECTOR_BENCHMARK_SUITE_EXTENSION_AND_WHITEPAPER_REFRESH_ALPHA.md`.

exp-123 keeps the exp-121 language surface unchanged and refreshes the current
publication baseline around one connected benchmark/documentation scope:

- `docs/SLOVO_WHITEPAPER.md` refreshed from the earlier exp-122 publication
  framing to the current language/tooling state through exp-121
- 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 benchmark refresh targets widened from seven rows to
  nine rows for the controller-owned publication pass
- local-machine-only wording, no threshold claim, and no cross-machine claim
  retained
- `docs/README.md`, README release metadata, and spec/roadmap wording aligned
  to the refreshed publication baseline

The matching publication artifacts remain `docs/SLOVO_WHITEPAPER.pdf` and
`WHITEPAPER.pdf`, regenerated after the paired controller-side benchmark data
refresh and release publication pass.

exp-123 does not add new source syntax, type forms, standard-library APIs,
compiler-known runtime names, optimizer guarantees, benchmark thresholds,
cross-machine performance claims, stable ABI/layout/ownership claims, or beta
maturity.

## exp-122 (released experimental alpha)

Release label: `exp-122`

Release name: Composite Data Benchmark Suite Extension And Whitepaper Refresh Alpha

Release date: 2026-05-21

Status: released experimental alpha documentation/tooling contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_122_COMPOSITE_DATA_BENCHMARK_SUITE_EXTENSION_AND_WHITEPAPER_REFRESH_ALPHA.md`.

exp-122 keeps the exp-121 language surface unchanged and refreshes the current
publication baseline around one connected benchmark/documentation scope:

- `docs/SLOVO_WHITEPAPER.md` refreshed from the earlier exp-119 publication
  framing to the current language/tooling state through exp-121
- benchmark methodology widened from five kernels to seven:
  `math-loop`, `branch-loop`, `parse-loop`, `array-index-loop`,
  `string-eq-loop`, `array-struct-field-loop`, and
  `enum-struct-payload-loop`
- paired same-machine benchmark refresh targets widened from five rows to
  seven rows for the controller-owned publication pass
- local-machine-only wording, no threshold claim, and no cross-machine claim
  retained
- `docs/README.md`, README release metadata, and spec/roadmap wording aligned
  to the refreshed publication baseline

The matching publication artifacts remain `docs/SLOVO_WHITEPAPER.pdf` and
`WHITEPAPER.pdf`, regenerated after the paired controller-side benchmark data
refresh and release publication pass.

exp-122 does not add new source syntax, type forms, standard-library APIs,
compiler-known runtime names, optimizer guarantees, benchmark thresholds,
cross-machine performance claims, stable ABI/layout/ownership claims, or beta
maturity.

## exp-121 (released experimental alpha)

Release label: `exp-121`

Release name: Non-Recursive Struct Enum Payloads Alpha

Release date: 2026-05-21

Status: released experimental alpha language contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_121_NON_RECURSIVE_STRUCT_ENUM_PAYLOADS_ALPHA.md`.

exp-121 broadens the enum payload surface with one connected struct-payload
scope:

- unary enum payload variants may use current known non-recursive struct types
- payload variants in one enum still share the same payload type when payload
  variants are present
- qualified payload constructors over those struct types
- immutable enum locals, parameters, returns, calls, tests, and `main`
- exhaustive `match` with one immutable payload binding
- existing field access behavior on bound struct payloads, including array
  field access and checked indexing where already promoted by exp-120

The matching supported and formatter fixtures are
`examples/supported/enum-payload-structs.slo` and
`examples/formatter/enum-payload-structs.slo`.

exp-121 does not add enum equality requirements for struct-payload enums,
direct array/vec/option/result payloads, multiple payload fields,
recursive/cyclic payloads, mutation, generics, stable ABI/layout/ownership
claims, or beta maturity.

## exp-120 (released experimental alpha)

Release label: `exp-120`

Release name: Fixed Array Struct Fields Alpha

Release date: 2026-05-21

Status: released experimental alpha language contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_120_FIXED_ARRAY_STRUCT_FIELDS_ALPHA.md`.

exp-120 broadens the struct-field surface with one connected fixed-array
scope:

- direct struct field declarations over `(array i32 N)`, `(array i64 N)`,
  `(array f64 N)`, `(array bool N)`, and `(array string N)`
- struct construction from matching fixed-array expressions
- immutable struct locals initialized from matching struct-valued expressions
- struct parameters and returns for structs carrying those field types
- calls returning structs carrying those field types
- field access returning the declared fixed-array type
- checked indexing through field access with `i32` expressions only

The matching supported and formatter fixtures are
`examples/supported/array-struct-fields.slo` and
`examples/formatter/array-struct-fields.slo`.

The earlier `array*` fixtures remain valid as the underlying fixed-array
lanes. The earlier `enum-struct-fields.slo`, `primitive-struct-fields.slo`,
`numeric-struct-fields.slo`, and `composite-struct-fields.slo` fixtures remain
valid as narrower or sibling struct-field lanes.

exp-120 does not add zero-length arrays, mutable arrays, element mutation,
field mutation, array equality, array printing, nested arrays, arrays of
unsupported element kinds, arrays inside unsupported containers, slices,
generics, stable ABI/layout/ownership claims, or beta maturity.

## exp-119 (released experimental alpha)

Release label: `exp-119`

Release name: Benchmark Suite Extension And Whitepaper Refresh Alpha

Release date: 2026-05-21

Status: released experimental alpha documentation/tooling contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_119_BENCHMARK_SUITE_EXTENSION_AND_WHITEPAPER_REFRESH_ALPHA.md`.

exp-119 keeps the exp-118 language surface unchanged and refreshes the current
publication baseline around one connected benchmark/documentation scope:

- `docs/SLOVO_WHITEPAPER.md` refreshed from the older exp-59 framing to the
  current language/tooling state through exp-118
- benchmark methodology widened from three kernels to five:
  `math-loop`, `branch-loop`, `parse-loop`, `array-index-loop`, and
  `string-eq-loop`
- benchmark result tables widened from three rows to five rows for paired
  same-machine publication refresh
- local-machine-only wording, no threshold claim, and no cross-machine claim
  retained
- `docs/README.md`, release metadata, and spec/roadmap wording aligned to the
  refreshed publication baseline

The matching publication artifacts remain `docs/SLOVO_WHITEPAPER.pdf` and
`WHITEPAPER.pdf`, regenerated after the paired controller-side benchmark data
refresh and release publication pass.

exp-119 does not add new source syntax, type forms, standard-library APIs,
compiler-known runtime names, optimizer guarantees, benchmark thresholds,
cross-machine performance claims, stable ABI/layout/ownership claims, or beta
maturity.

## exp-118 (released experimental alpha)

Release label: `exp-118`

Release name: String Fixed Arrays Alpha

Release date: 2026-05-21

Status: released experimental alpha language contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_118_STRING_FIXED_ARRAYS_ALPHA.md`.

exp-118 broadens the fixed-array surface with one connected string-array
scope:

- fixed array types over `string`
- positive literal lengths only
- direct array constructors over `string`
- immutable array locals initialized from matching array-valued expressions
- fixed-array parameters and returns over `string`
- calls returning arrays over `string`
- checked literal indexing and runtime-checked dynamic indexing
- `i32` index expressions only

The matching supported and formatter fixtures are
`examples/supported/array-string.slo`,
`examples/formatter/array-string.slo`,
`examples/supported/array-string-value-flow.slo`, and
`examples/formatter/array-string-value-flow.slo`.

The earlier `examples/supported/array.slo` and
`examples/supported/array-value-flow.slo` fixtures remain valid as narrower
`i32`-only predecessors. The earlier `array-direct-scalars*` fixtures remain
valid as the direct scalar widening lane from exp-117.

exp-118 does not add zero-length arrays, mutable arrays, element mutation,
array equality, printing arrays, nested arrays, arrays in struct fields,
arrays of other unsupported element types, slices, generics, stable
ABI/layout/ownership claims for string elements, or beta maturity.

## exp-117 (released experimental alpha)

Release label: `exp-117`

Release name: Direct Scalar Fixed Arrays Alpha

Release date: 2026-05-21

Status: released experimental alpha language contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_117_DIRECT_SCALAR_FIXED_ARRAYS_ALPHA.md`.

exp-117 broadens the fixed-array surface with one connected direct-scalar
scope:

- fixed array types over `i32`, `i64`, `f64`, and `bool`
- positive literal lengths only
- direct array constructors over those element families
- immutable array locals initialized from matching array-valued expressions
- fixed-array parameters and returns over those element families
- calls returning arrays over those element families
- checked literal indexing and runtime-checked dynamic indexing
- `i32` index expressions only

The matching supported and formatter fixtures are
`examples/supported/array-direct-scalars.slo`,
`examples/formatter/array-direct-scalars.slo`,
`examples/supported/array-direct-scalars-value-flow.slo`, and
`examples/formatter/array-direct-scalars-value-flow.slo`.

The earlier `examples/supported/array.slo` and
`examples/supported/array-value-flow.slo` fixtures remain valid as narrower
`i32`-only predecessors.

exp-117 does not add zero-length arrays, mutable arrays, element mutation,
array equality, printing arrays, nested arrays, arrays in struct fields, string
arrays, arrays of other unsupported element types, slices, generics, stable
ABI/layout claims, or beta maturity.

## exp-116 (released experimental alpha)

Release label: `exp-116`

Release name: Direct Scalar And String Enum Payloads Alpha

Release date: 2026-05-21

Status: released experimental alpha language contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_116_DIRECT_SCALAR_AND_STRING_ENUM_PAYLOADS_ALPHA.md`.

exp-116 broadens the user-defined enum payload surface with one connected
direct-payload scope:

- payloadless variants remain supported
- unary `(Variant i32)` payload variants remain supported
- unary direct `(Variant i64)` payload variants
- unary direct `(Variant f64)` payload variants
- unary direct `(Variant bool)` payload variants
- unary direct `(Variant string)` payload variants
- qualified zero-argument payloadless constructors and qualified one-argument
  payload constructors
- immutable enum locals, parameters, returns, calls, top-level tests, and
  `main`
- exhaustive enum `match` with one immutable arm-local payload binding for
  payload variants
- same-enum equality by tag for payloadless variants and by tag plus payload
  for unary direct payload variants

The matching supported and formatter fixtures are
`examples/supported/enum-payload-direct-scalars.slo` and
`examples/formatter/enum-payload-direct-scalars.slo`.

exp-116 does not add mixed payload kinds inside one enum, multiple payloads,
record variants, tuple variants beyond one direct payload, vec/array/option/
result/struct/enum payloads, enum mutation, richer pattern families, generic
enums, methods, traits, new compiler-known runtime names, manifest schema
changes, or beta maturity.

## exp-115 (released experimental alpha)

Release label: `exp-115`

Release name: Composite Struct Fields And Nested Structs Alpha

Release date: 2026-05-21

Status: released experimental alpha language contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_115_COMPOSITE_STRUCT_FIELDS_AND_NESTED_STRUCTS_ALPHA.md`.

exp-115 broadens the struct-field surface with one connected composite-field
scope:

- direct struct fields over `(vec i32)`, `(vec i64)`, `(vec f64)`,
  `(vec bool)`, and `(vec string)`
- direct struct fields over `(option i32)`, `(option i64)`, `(option f64)`,
  `(option bool)`, and `(option string)`
- direct struct fields over `(result i32 i32)`, `(result i64 i32)`,
  `(result f64 i32)`, `(result bool i32)`, and `(result string i32)`
- direct struct fields over current known non-recursive struct types
- coexistence with the already supported direct scalar, immutable string, and
  current enum field families
- immutable struct locals, parameters, returns, calls, top-level tests, and
  `main` for structs carrying those fields

The matching supported and formatter fixtures are
`examples/supported/composite-struct-fields.slo` and
`examples/formatter/composite-struct-fields.slo`.

exp-115 does not add arrays as struct fields, mutable arrays, field mutation,
vector element mutation, option/result payload mutation, enum payload
mutation, recursive or cyclic struct layouts, new compiler-known runtime
names, manifest schema changes, or beta maturity.

## exp-114 (released experimental alpha)

Release label: `exp-114`

Release name: Mutable Composite Locals Alpha

Release date: 2026-05-21

Status: released experimental alpha language contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_114_MUTABLE_COMPOSITE_LOCALS_ALPHA.md`.

exp-114 broadens the local-value surface with one connected mutable-composite
scope:

- same-type mutable whole-value `var` / `set` reassignment for `string`
- same-type mutable whole-value `var` / `set` reassignment for `(vec i32)`,
  `(vec i64)`, `(vec f64)`, `(vec bool)`, and `(vec string)`
- same-type mutable whole-value `var` / `set` reassignment for current
  concrete option/result families
- same-type mutable whole-value `var` / `set` reassignment for current known
  struct values and current enum values
- ordinary function bodies, top-level tests, and `main`

The matching supported and formatter fixtures are
`examples/supported/composite-locals.slo` and
`examples/formatter/composite-locals.slo`.

exp-114 does not add array mutation or mutable arrays, field mutation, vector
element mutation, option/result payload mutation, enum payload mutation,
mixed-type assignment, new compiler-known runtime names, manifest schema
changes, or beta maturity.

## exp-113 (released experimental alpha)

Release label: `exp-113`

Release name: Mutable Scalar Locals Alpha

Release date: 2026-05-21

Status: released experimental alpha language contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_113_MUTABLE_SCALAR_LOCALS_ALPHA.md`.

exp-113 broadens the local-value surface with one connected mutable-scalar
scope:

- direct mutable `var` locals declared as `bool`, `i64`, and `f64`
- same-type `set` reassignment from already promoted scalar expressions for
  those declared local types
- ordinary function bodies, top-level tests, and `main`

The matching supported and formatter fixtures remain
`examples/supported/local-variables.slo` and
`examples/formatter/local-variables.slo`, now broadened to include mutable
`bool`, `i64`, and `f64` local var/set flows alongside the earlier i32 local
forms and exp-112 immutable bool locals.

exp-113 does not add mutable `string` locals, vector mutation, option/result
mutation, struct or enum mutation, mixed-type assignment, new compiler-known
runtime names, manifest schema changes, or beta maturity.

## exp-112 (released experimental alpha)

Release label: `exp-112`

Release name: Immutable Bool Locals Alpha

Release date: 2026-05-21

Status: released experimental alpha language contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_112_IMMUTABLE_BOOL_LOCALS_ALPHA.md`.

exp-112 broadens the local-value surface with one connected immutable-bool
scope:

- direct immutable `let` locals declared as `bool`
- local initializers from already promoted bool literals, parameters, calls
  returning bool, and `if` expressions returning bool
- local references in existing predicate, return, call, top-level test, and
  `main` positions

The matching supported and formatter fixtures remain
`examples/supported/local-variables.slo` and
`examples/formatter/local-variables.slo`, now broadened to include direct
immutable bool locals alongside the earlier i32 local forms. The current
`examples/projects/std-import-io/` explicit import fixture also now uses
direct bool locals in its stdin bool-fallback helper path.

exp-112 does not add mutable bool locals, bool assignment, `var bool`, new
boolean operators, broader local-type widening, new compiler-known runtime
names, manifest schema changes, or beta maturity.

## exp-111 (released experimental alpha)

Release label: `exp-111`

Release name: Standard IO Stdin Source Helpers Alpha

Release date: 2026-05-21

Status: released experimental alpha stdlib/source contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_111_STANDARD_IO_STDIN_SOURCE_HELPERS_ALPHA.md`.

exp-111 broadens `std/io.slo` with one connected stdin helper package:

- `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`
- `read_stdin_bool_or`

The existing zero-returning and value-returning print helper surfaces remain
in place. All new helpers remain ordinary Slovo source over the already
promoted `std.io.read_stdin_result`, the released `std.string.parse_*_result`
helpers, and the exp-109 `std.result.ok_or_none_*` bridge helpers. The
scope adds no new compiler-known `std.*` names, no generics, and no new
runtime calls. The matching explicit import fixture
`examples/projects/std-import-io/` now exercises the expanded stdin helper
lane structurally instead of assuming a fixed runner stdin payload.

exp-111 does not add trap-based `std.io.read_stdin`, line/read-line APIs,
prompt APIs, terminal mode, binary stdin, streaming stdin, async IO,
generics, compiler-known `std.*` runtime names beyond the already released
lane, or beta maturity.

## exp-110 (released experimental alpha)

Release label: `exp-110`

Release name: Standard String, Env, Fs, Process, And Cli Option Helpers Alpha

Release date: 2026-05-21

Status: released experimental alpha stdlib/source contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_110_STANDARD_STRING_ENV_FS_PROCESS_AND_CLI_OPTION_HELPERS_ALPHA.md`.

exp-110 broadens `std/string.slo`, `std/env.slo`, `std/fs.slo`,
`std/process.slo`, and `std/cli.slo` with one connected option-helper
package:

- `std.string`: `parse_i32_option`, `parse_i64_option`,
  `parse_f64_option`, `parse_bool_option`
- `std.env`: `get_option`, `get_i32_option`, `get_i64_option`,
  `get_f64_option`, `get_bool_option`
- `std.fs`: `read_text_option`, `read_i32_option`, `read_i64_option`,
  `read_f64_option`, `read_bool_option`
- `std.process`: `arg_option`, `arg_i32_option`, `arg_i64_option`,
  `arg_f64_option`, `arg_bool_option`
- `std.cli`: `arg_text_option`, `arg_i32_option`, `arg_i64_option`,
  `arg_f64_option`, `arg_bool_option`

The existing direct/result/fallback helper surfaces remain in place for all
five staged modules. All new helpers remain ordinary Slovo source over the
existing concrete result lanes through the exp-109 `std.result.ok_or_none_*`
bridge helpers. The scope adds no new compiler-known `std.*` names, no
generics, no new runtime calls, no stdin helpers, and no vec work.

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 deterministically exercise the new
option helpers alongside the earlier result and fallback lanes.

exp-110 does not add generic option/result combinators, automatic or
compiler-loaded std imports, stable ABI/layout claims, or beta maturity.

## exp-109 (released experimental alpha)

Release label: `exp-109`

Release name: Standard Option And Result Bridge Helpers Alpha

Release date: 2026-05-21

Status: released experimental alpha stdlib/source contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_109_STANDARD_OPTION_AND_RESULT_BRIDGE_HELPERS_ALPHA.md`.

exp-109 broadens `std/option.slo` and `std/result.slo` with one connected
bridge-helper package between the current concrete option and result
families:

- `std/option.slo`: `some_or_err_i32`, `some_or_err_i64`,
  `some_or_err_f64`, `some_or_err_bool`, `some_or_err_string`
- `std/result.slo`: `ok_or_none_i32`, `ok_or_none_i64`,
  `ok_or_none_string`, `ok_or_none_f64`, `ok_or_none_bool`

The existing concrete constructor, observer, unwrap, and fallback helpers
remain in place for both staged modules. All new helpers remain ordinary
Slovo source. `some_or_err_*` uses the existing raw `is_some`,
`unwrap_some`, `ok`, and `err` forms to produce `(result <payload> i32)`
without importing `std.result`. `ok_or_none_*` uses the existing
`std.result.is_ok`, `std.result.unwrap_ok`, `some`, and `none` forms to
produce `(option <payload>)` without importing `std.option`.

The matching explicit import fixtures,
`examples/projects/std-import-option/`,
`examples/workspaces/std-import-option/`, and
`examples/projects/std-import-result/`, now deterministically exercise the
new bridge helpers alongside the earlier concrete helper surfaces. The
project option fixture now passes 26 deterministic tests, the workspace
option fixture passes 1 deterministic test, and the project result fixture
passes 18 deterministic tests.

exp-109 does not add compiler-known `std.*` names, generic bridge helpers,
generic `map`/`and_then`/`transpose`/`flatten`, new payload families,
automatic or compiler-loaded std imports, stable ABI/layout claims, or beta
maturity.

## exp-108 (released experimental alpha)

Release label: `exp-108`

Release name: Standard Vec String, F64, And Bool Prefix And Suffix Helpers Alpha

Release date: 2026-05-21

Status: released experimental alpha stdlib/source contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_108_STANDARD_VEC_STRING_F64_AND_BOOL_PREFIX_AND_SUFFIX_HELPERS_ALPHA.md`.

exp-108 broadens `std/vec_string.slo`, `std/vec_f64.slo`, and
`std/vec_bool.slo` from their released edit baselines with one connected
immutable prefix/suffix package:

- `starts_with`
- `without_prefix`
- `ends_with`
- `without_suffix`

The baseline direct wrappers, builder helpers, query helpers, option-query
helpers, transform helpers, subvec helper, edit helpers, and simple
real-program helpers remain in place for the three concrete vec families.
All new helpers remain ordinary Slovo source over the four already released
runtime calls for each family plus existing helper composition. Empty
prefixes and suffixes behave as identity boundaries, exact whole-vector
prefix/suffix matches collapse to `empty`, and mismatched prefixes or
suffixes leave the input vector unchanged for the corresponding
`without_prefix` or `without_suffix` call.

The matching explicit import fixtures,
`examples/projects/std-import-vec_string/`,
`examples/projects/std-import-vec_f64/`, and
`examples/projects/std-import-vec_bool/`, now deterministically exercise the
baseline, option-query, prefix/suffix, transform, subvec, edit, and
real-program helper groups through explicit imports. Each project now passes
19 deterministic fixture tests.

exp-108 does not add compiler-known `std.*` names beyond the already
released vec-string, vec-f64, and vec-bool runtime families, generics,
sorting, mapping, filtering, nested/container vecs, mutating/capacity APIs,
automatic or compiler-loaded std imports, stable ABI/layout claims, or beta
maturity.

## exp-107 (released experimental alpha)

Release label: `exp-107`

Release name: Standard Vec String, F64, And Bool Edit Helpers Alpha

Release date: 2026-05-21

Status: released experimental alpha stdlib/source contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_107_STANDARD_VEC_STRING_F64_AND_BOOL_EDIT_HELPERS_ALPHA.md`.

exp-107 broadens `std/vec_string.slo`, `std/vec_f64.slo`, and
`std/vec_bool.slo` from their released option-query and transform baselines
with one connected immutable edit package:

- `insert_at`
- `insert_range`
- `replace_at`
- `replace_range`
- `remove_at`
- `remove_range`

The baseline direct wrappers, builder helpers, query helpers, option-query
helpers, transform helpers, subvec helper, and simple real-program helpers
remain in place for the three concrete vec families. All new helpers remain
ordinary Slovo source over the four already released runtime calls for each
family plus existing helper composition. `insert_at` appends on exact-length
positions and otherwise leaves invalid negative or past-end positions
unchanged; `insert_range` behaves the same for whole-vector insertion;
`replace_at` changes one in-range position or returns the original vector;
`replace_range` replaces a half-open in-range segment with tail saturation;
`remove_at` removes one in-range position or returns the original vector;
and `remove_range` removes a half-open in-range segment with tail saturation.

The matching explicit import fixtures,
`examples/projects/std-import-vec_string/`,
`examples/projects/std-import-vec_f64/`, and
`examples/projects/std-import-vec_bool/`, now deterministically exercise the
baseline, option-query, transform, subvec, edit, and real-program helper
groups through explicit imports. Each project now passes 15 deterministic
fixture tests.

exp-107 does not add compiler-known `std.*` names beyond the already
released vec-string, vec-f64, and vec-bool runtime families, generics,
prefix/suffix helpers, sorting, mapping, filtering, nested/container vecs,
mutating/capacity APIs, automatic or compiler-loaded std imports, stable
ABI/layout claims, or beta maturity.

## exp-106 (released experimental alpha)

Release label: `exp-106`

Release name: Standard Vec F64 And Bool Option Query Helpers Alpha

Release date: 2026-05-21

Status: released experimental alpha stdlib/source contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_106_STANDARD_VEC_F64_AND_BOOL_OPTION_QUERY_HELPERS_ALPHA.md`.

exp-106 broadens `std/vec_f64.slo` and `std/vec_bool.slo` from their
released transform baselines with one connected option-query package:

- `index_option`
- `first_option`
- `last_option`
- `index_of_option`
- `last_index_of_option`

The baseline direct wrappers, builder helpers, query helpers, transform
helpers, subvec helper, and simple real-program helpers remain in place for
both concrete vec families. All new helpers remain ordinary Slovo source
over the four already released runtime calls for each family and the already
promoted concrete option families they return. `index_option` returns `none`
for negative and out-of-range positions; `first_option` delegates to
`index_option values 0`; `last_option` returns `none` for empty vectors and
`some` of the last element otherwise; `index_of_option` returns the first
matching position or `none`; and `last_index_of_option` returns the last
matching position or `none`.

The matching explicit import fixtures,
`examples/projects/std-import-vec_f64/` and
`examples/projects/std-import-vec_bool/`, now deterministically exercise the
baseline, option-query, transform, subvec, and real-program helper groups
through explicit `(import std.vec_f64 (...))` and `(import std.vec_bool
(...))`. Each project now passes 9 deterministic fixture tests.

exp-106 does not add compiler-known `std.*` names beyond the already
released vec-f64 and vec-bool runtime families, generics, edit helpers,
nested/container vecs, mutating/capacity APIs, automatic or compiler-loaded
std imports, stable ABI/layout claims, or beta maturity.

## exp-105 (released experimental alpha)

Release label: `exp-105`

Release name: Standard Vec F64 And Bool Transform Helpers Alpha

Release date: 2026-05-21

Status: released experimental alpha stdlib/source contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_105_STANDARD_VEC_F64_AND_BOOL_TRANSFORM_HELPERS_ALPHA.md`.

exp-105 broadens `std/vec_f64.slo` and `std/vec_bool.slo` from their
released baselines with one connected transform-helper package:

- `concat`
- `take`
- `drop`
- `reverse`
- `subvec`

The baseline direct wrappers, builder helpers, query helpers, and simple
real-program helpers remain in place for both concrete vec families. All new
helpers remain ordinary Slovo source over the four already released runtime
calls for each family. `take` treats negative counts as zero and saturates
to the full source vector, `drop` treats negative counts as zero and
saturates at the source tail, `reverse` returns a copied reverse-order
vector, and `subvec` returns a copied half-open range or `empty` for
negative or empty starts.

The matching explicit import fixtures,
`examples/projects/std-import-vec_f64/` and
`examples/projects/std-import-vec_bool/`, now deterministically exercise the
baseline, transform, subvec, and real-program helper groups through explicit
`(import std.vec_f64 (...))` and `(import std.vec_bool (...))`. Each project
now passes 8 deterministic fixture tests.

exp-105 does not add compiler-known `std.*` names beyond the already
released vec-f64 and vec-bool runtime families, generics, option/result
helpers, edit helpers, nested/container vecs, mutating/capacity APIs,
automatic or compiler-loaded std imports, stable ABI/layout claims, or beta
maturity.

## exp-104 (released experimental alpha)

Release label: `exp-104`

Release name: Standard Vec Bool Baseline Alpha

Release date: 2026-05-21

Status: released experimental alpha stdlib/source contract, not beta.

The normative Slovo-side contract target is
`.llm/EXP_104_STANDARD_VEC_BOOL_BASELINE_ALPHA.md`.

exp-104 stages `std/vec_bool.slo` as the first source-authored `(vec bool)`
facade over the sibling concrete `std.vec.bool` runtime family.

The frozen source helper surface is:

- direct wrappers: `empty`, `append`, `len`, `at`
- builder helpers: `singleton`, `append2`, `append3`, `pair`, `triple`
- query helpers: `is_empty`, `index_or`, `first_or`, `last_or`
- simple real-program helpers: `contains`, `count_of`

All helpers remain ordinary Slovo source over the four released vec-bool
runtime calls. `index_or` returns its fallback for negative and out-of-range
positions, `first_or` delegates to `index_or values 0 fallback`, `last_or`
returns its fallback for empty vectors and the final element otherwise,
`contains` returns `true` exactly when some element equals the target, and
`count_of` returns `0` for empty vectors and counts repeated matches exactly.

The matching explicit import fixture,
`examples/projects/std-import-vec_bool/`, freezes deterministic direct,
builder, query, and real-program helper coverage through explicit
`(import std.vec_bool (...))`. The matching supported and formatter fixtures,
`examples/supported/vec-bool.slo` and `examples/formatter/vec-bool.slo`,
exercise the intended raw `std.vec.bool.*` runtime surface, append
immutability, concrete `(vec bool)` flow, and same-family vector equality on
the Slovo side.

exp-104 does not add compiler-known `std.*` names beyond the released vec-bool
runtime family, generics, option/result helpers, transform/range/edit
helpers, nested/container vecs, mutating/capacity APIs, automatic or
compiler-loaded std imports, stable ABI/layout claims, or beta maturity.

## exp-103 (released experimental alpha)

Release label: `exp-103`

Release name: Standard Vec F64 Baseline Alpha

Release date: 2026-05-21

Status: released experimental alpha stdlib/source contract plus concrete
vector-family contract. This is experimental maturity and not a beta
maturity claim.

The normative release contract is
`.llm/EXP_103_STANDARD_VEC_F64_BASELINE_ALPHA.md`.

exp-103 adds `std/vec_f64.slo` as the first usable source-authored
`(vec f64)` facade over the sibling concrete `std.vec.f64` runtime family.

The staged source helper surface is:

- direct wrappers: `empty`, `append`, `len`, `at`
- builder helpers: `singleton`, `append2`, `append3`, `pair`, `triple`
- query helpers: `is_empty`, `index_or`, `first_or`, `last_or`
- simple real-program helpers: `contains`, `sum`

All helpers remain ordinary Slovo source over the four promoted vec-f64
runtime calls. `index_or` returns its fallback for negative and out-of-range
positions, `first_or` delegates to `index_or values 0 fallback`, `last_or`
returns its fallback for empty vectors and the final element otherwise,
`contains` returns `true` exactly when some element equals the target, and
`sum` returns `0.0` for empty vectors.

The matching explicit import fixture,
`examples/projects/std-import-vec_f64/`, deterministically exercises the
direct wrappers, builder helpers, query helpers, and real-program helpers
through explicit `(import std.vec_f64 (...))`. The matching supported and
formatter fixtures, `examples/supported/vec-f64.slo` and
`examples/formatter/vec-f64.slo`, exercise the compiler-known
`std.vec.f64.*` runtime surface, append immutability, concrete `(vec f64)`
flow, and same-family vector equality.

exp-103 does not add compiler-known `std.*` names beyond the vec-f64 runtime
family, generics, option-query helpers, transform/range/edit helpers,
nested/container vecs, automatic or compiler-loaded std imports, stable
ABI/layout claims, or beta maturity.

## exp-102 (released experimental alpha)

Release label: `exp-102`

Release name: Standard Option Bool And F64 Baseline Alpha

Release date: 2026-05-21

Status: released experimental alpha source/core-language contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_102_STANDARD_OPTION_BOOL_AND_F64_BASELINE_ALPHA.md`.

exp-102 broadens the staged `std/option.slo` helper surface and the current
core-language option slice from concrete `(option i32)`, `(option i64)`, and
`(option string)` to those families plus concrete `(option f64)` and
`(option bool)`.

The staged source helper surface is now:

- `(option i32)`: `some_i32`, `none_i32`, `is_some_i32`, `is_none_i32`,
  `unwrap_some_i32`, `unwrap_or_i32`
- `(option i64)`: `some_i64`, `none_i64`, `is_some_i64`, `is_none_i64`,
  `unwrap_some_i64`, `unwrap_or_i64`
- `(option f64)`: `some_f64`, `none_f64`, `is_some_f64`, `is_none_f64`,
  `unwrap_some_f64`, `unwrap_or_f64`
- `(option bool)`: `some_bool`, `none_bool`, `is_some_bool`, `is_none_bool`,
  `unwrap_some_bool`, `unwrap_or_bool`
- `(option string)`: `some_string`, `none_string`, `is_some_string`,
  `is_none_string`, `unwrap_some_string`, `unwrap_or_string`

All helpers remain ordinary Slovo source over the already promoted option
forms, observers, extraction, `if`, parameters, and explicit signatures.
The release also broadens the supported and formatter `option-result*`
fixtures so raw option returns, immutable value flow, payload extraction, and
source-level `match` now cover `(option f64)` and `(option bool)` as well.

The matching explicit import fixture,
`examples/projects/std-import-option/`, now deterministically exercises the
`i32`, `i64`, `f64`, `bool`, and `string` helper families, with 16 passed
tests in the explicit project fixture. The matching workspace fixture,
`examples/workspaces/std-import-option/`, broadens the same staged helper
surface through the existing explicit workspace source-search lane.

exp-102 does not add compiler-known `std.option.*` runtime names, generic
option helpers, option payload families beyond `i32`, `i64`, `f64`, `bool`,
and `string`, option equality, option printing, nested/container option
support, automatic or compiler-loaded std imports, stable ABI/layout claims,
or beta maturity.

## exp-101 (released experimental alpha)

Release label: `exp-101`

Release name: Standard Vec String Option And Transform Helpers Alpha

Release date: 2026-05-21

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_101_STANDARD_VEC_STRING_OPTION_AND_TRANSFORM_HELPERS_ALPHA.md`.

exp-101 broadens `std/vec_string.slo` from the exp-99 baseline with one
connected helper package:

- option-query helpers:
  `index_option`, `first_option`, `last_option`, `index_of_option`,
  `last_index_of_option`
- transform helpers:
  `concat`, `take`, `drop`, `reverse`, `subvec`

The baseline direct wrappers, builder helpers, query helpers, and simple
real-program helpers remain in place. The new helpers stay ordinary Slovo
source over the existing `std.vec.string.*` facade operations, string
equality, integer comparisons, and raw current `(option string)` /
`(option i32)` forms. The lane stays recursive and immutable with no `var`
or `set`.

The matching explicit import fixture, `examples/projects/std-import-vec_string/`,
now deterministically exercises the baseline, option-query, transform,
subvec, and real-program helper groups, with 9 passed tests in the explicit
project fixture.

exp-101 does not add compiler-known `std.*` runtime names, generics, vec
element families beyond `i32`, `i64`, and `string`, edit helpers,
prefix/suffix helpers, nested vecs or vecs inside other containers,
mutating/capacity APIs, stable ABI/layout claims, or beta maturity.

## exp-100 (released experimental alpha)

Release label: `exp-100`

Release name: Standard Option String Baseline Alpha

Release date: 2026-05-21

Status: released experimental alpha source/core-language contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_100_STANDARD_OPTION_STRING_BASELINE_ALPHA.md`.

exp-100 broadens the staged `std/option.slo` helper surface and the current
core-language option slice from concrete `(option i32)` plus `(option i64)`
to concrete `(option i32)`, `(option i64)`, and `(option string)`.

The staged source helper surface is now:

- `(option i32)`: `some_i32`, `none_i32`, `is_some_i32`, `is_none_i32`,
  `unwrap_some_i32`, `unwrap_or_i32`
- `(option i64)`: `some_i64`, `none_i64`, `is_some_i64`, `is_none_i64`,
  `unwrap_some_i64`, `unwrap_or_i64`
- `(option string)`: `some_string`, `none_string`, `is_some_string`,
  `is_none_string`, `unwrap_some_string`, `unwrap_or_string`

All helpers remain ordinary Slovo source over the already promoted option
forms, tag observers, extraction, `if`, parameters, and explicit
signatures. The release also broadens the supported and formatter
`option-result*` fixtures so raw option returns, immutable value flow,
payload extraction, and source-level `match` now cover `(option string)` as
well.

The matching explicit import fixture,
`examples/projects/std-import-option/`, now deterministically exercises the
`i32`, `i64`, and `string` helper families, with 10 passed tests in the
explicit project fixture. The matching workspace fixture,
`examples/workspaces/std-import-option/`, broadens the same staged helper
surface through the existing explicit workspace source-search lane.

exp-100 does not add compiler-known `std.option.*` runtime names, generic
option helpers, option payload families beyond `i32`, `i64`, and `string`,
option equality, option printing, nested/container option support, automatic
or compiler-loaded std imports, stable ABI/layout claims, or beta maturity.

## exp-99 (released experimental alpha)

Release label: `exp-99`

Release name: Standard Vec String Baseline Alpha

Release date: 2026-05-21

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_99_STANDARD_VEC_STRING_BASELINE_ALPHA.md`.

exp-99 adds `std/vec_string.slo` as the first usable source-authored
`(vec string)` facade over the sibling concrete `std.vec.string` runtime
family. Its public surface is:

- direct wrappers: `empty`, `append`, `len`, and `at`
- builder helpers: `singleton`, `append2`, `append3`, `pair`, and `triple`
- query helpers: `is_empty`, `index_or`, `first_or`, and `last_or`
- simple real-program helpers: `contains` and `count_of`

The direct wrappers call only `std.vec.string.empty`,
`std.vec.string.append`, `std.vec.string.len`, and `std.vec.string.index`.
The remaining helpers are ordinary deterministic Slovo source helpers over
that direct surface, string equality, integer comparison, and `i32`
counting. `index_or` returns its fallback for negative and out-of-range
positions, `first_or` delegates to `index_or values 0 fallback`, `last_or`
provides a stable empty-vector fallback, `contains` returns `true` exactly
when any element equals the target, and `count_of` returns `0` for empty
vectors or absent targets while counting repeated matches exactly.

The matching explicit import fixture, `examples/projects/std-import-vec_string/`,
deterministically exercises the direct facade plus the builder, query,
contains, and count_of helpers, with 6 passed tests in the explicit project
fixture. The release also adds `examples/supported/vec-string.slo` with
matching formatter coverage in `examples/formatter/vec-string.slo` for the raw
`std.vec.string.*` runtime surface, vector equality, and append immutability.

exp-99 does not add generics, vec element families beyond `i32`, `i64`, and
`string`, option-query helpers, transform/range/edit helpers, nested vecs or
vecs inside other containers, mutating/capacity APIs, stable ABI/layout
claims, or beta maturity.

## exp-98 (released experimental alpha)

Release label: `exp-98`

Release name: Standard Vec I64 Edit Helpers Alpha

Release date: 2026-05-21

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_98_STANDARD_VEC_I64_EDIT_HELPERS_ALPHA.md`.

exp-98 extends `std/vec_i64.slo` with exactly six new public helpers over
the existing concrete vec i64 runtime family:

- `insert_at`
- `insert_range`
- `replace_at`
- `replace_range`
- `remove_at`
- `remove_range`

The helper surface stays concrete to `(vec i64)` and remains source-authored
and compositional over the already released vec_i64 helper surface,
especially `concat`, `take`, `drop`, and `append`. The full `vec_i64`
source family stays recursive and immutable: there are no `var` or `set`
locals in `std/vec_i64.slo`.

`insert_at ((values (vec i64)) (position i32) (value i64)) -> (vec i64)`
inserts before the current element at an in-range `position`, appends at
`position == len(values)`, and returns `values` unchanged for negative or
greater-than-length positions. `insert_range ((values (vec i64))
(position i32) (inserted (vec i64))) -> (vec i64)` follows the same
position rules while preserving the order of both vectors. `replace_at`
replaces one in-range element and returns `values` unchanged for negative or
out-of-range positions. `replace_range ((values (vec i64)) (start i32)
(end_exclusive i32) (replacement (vec i64))) -> (vec i64)` replaces the
half-open range `[start, end_exclusive)`, returns `values` unchanged for
negative, empty, or past-end starts, and replaces the tail when
`end_exclusive` extends past the source length. `remove_at` removes one
in-range element and otherwise returns `values` unchanged. `remove_range`
removes the half-open range `[start, end_exclusive)`, returns `values`
unchanged for negative, empty, or past-end starts, and removes the tail
when `end_exclusive` extends past the source length.

The matching explicit import fixture, `examples/projects/std-import-vec_i64/`,
deterministically exercises the new edit helper package alongside the
earlier builder, query, option-query, transform, subvec, and real-program
groups, with 15 passed tests in the explicit project fixture.

exp-98 does not add generics, new compiler-known `std.*` runtime names,
mutation/capacity APIs, iterators, sort/map/filter, or beta maturity.

## exp-97 (released experimental alpha)

Release label: `exp-97`

Release name: Standard Vec I64 Transform Helpers Alpha

Release date: 2026-05-21

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_97_STANDARD_VEC_I64_TRANSFORM_HELPERS_ALPHA.md`.

exp-97 extends `std/vec_i64.slo` with exactly five new public helpers over
the existing concrete vec i64 runtime family:

- `concat`
- `take`
- `drop`
- `reverse`
- `subvec`

The helper surface stays concrete to `(vec i64)` and remains source-authored
over the existing `append`, `len`, `at`, and `empty` facade operations only.
The full `vec_i64` source family stays recursive and immutable: there are no
`var` or `set` locals in `std/vec_i64.slo`.

`concat ((left (vec i64)) (right (vec i64))) -> (vec i64)` preserves the
order of both inputs and returns a copied left-then-right result. `take`
treats negative counts as zero and returns the original vector when the
requested count reaches or exceeds the current length. `drop` treats
negative counts as zero and returns an empty vector when the requested count
reaches or exceeds the current length. `reverse` returns a copied vector in
reverse order. `subvec ((values (vec i64)) (start i32) (end_exclusive i32))
-> (vec i64)` returns a copied half-open range, returns `(empty)` for
negative or empty ranges, and returns the remaining tail when
`end_exclusive` extends past the source length.

The matching explicit import fixture, `examples/projects/std-import-vec_i64/`,
deterministically exercises the new transform helper package alongside the
earlier direct-wrapper, builder, query, option-query, contains, and sum
groups, with 9 passed tests in the explicit project fixture.

exp-97 does not add insert/replace/remove helpers for `(vec i64)`, generics,
new compiler-known `std.*` runtime names, mutation/capacity APIs, iterators,
sort/map/filter, or beta maturity.

## exp-96 (released experimental alpha)

Release label: `exp-96`

Release name: Standard Vec I64 Option Query Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_96_STANDARD_VEC_I64_OPTION_QUERY_HELPERS_ALPHA.md`.

exp-96 extends `std/vec_i64.slo` with exactly five new public helpers over
the existing concrete vec i64 runtime family:

- `index_option`
- `first_option`
- `last_option`
- `index_of_option`
- `last_index_of_option`

The option-returning helper surface stays concrete to `(option i64)` and
`(option i32)`. The module stays self-contained and explicit by constructing
raw current `some` and `none` option values directly instead of importing
`std.option`.

`index_option ((values (vec i64)) (position i32)) -> (option i64)` returns
`(none i64)` for negative and out-of-range positions and `(some i64 ...)`
for in-range positions. `first_option` delegates to `index_option values 0`.
`last_option` returns `(none i64)` for empty vectors and the final element as
`(some i64 ...)` otherwise. `index_of_option` returns the first matching
position as `(some i32 ...)` and `(none i32)` when the target is absent.
`last_index_of_option` returns the last matching position as `(some i32 ...)`
and `(none i32)` when the target is absent.

The full `vec_i64` source family now stays recursive and immutable: there are
no `var` or `set` locals in `std/vec_i64.slo`. The matching explicit import
fixture, `examples/projects/std-import-vec_i64/`, deterministically exercises
the new option-query helper group alongside the earlier direct-wrapper,
builder, query, contains, and sum groups, with 7 passed tests in the explicit
project fixture.

exp-96 does not add transform/range/edit helpers for `(vec i64)`, generics,
new compiler-known `std.*` runtime names, mutation/capacity APIs, iterators,
sort/map/filter, or beta maturity.

## exp-95 (released experimental alpha)

Release label: `exp-95`

Release name: Standard Option I64 Baseline Alpha

Release date: 2026-05-20

Status: released experimental alpha source/core-language contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_95_STANDARD_OPTION_I64_BASELINE_ALPHA.md`.

exp-95 broadens the conservative option slice from only `(option i32)` to
concrete `(option i32)` plus `(option i64)`.

On the staged standard-library side, `std/option.slo` now includes:

- constructors: `some_i32`, `none_i32`, `some_i64`, `none_i64`
- observers: `is_some_i32`, `is_none_i32`, `is_some_i64`, `is_none_i64`
- extract/fallback helpers: `unwrap_some_i32`, `unwrap_or_i32`,
  `unwrap_some_i64`, and `unwrap_or_i64`

On the conservative core-language side, exp-95 broadens immutable option value
flow, direct constructor returns, tag observation, trap-based payload
extraction, and source-level `match` to `(option i64)`. The matching Slovo
fixtures now exercise raw `(option i64)` returns, value flow, payload access,
and `match`, and the explicit `std.option` import project now exercises both
the `i32` and `i64` helper families.

exp-95 does not add compiler-known `std.*` runtime names, automatic `std`
imports/search, generic option helpers, option payload families beyond `i32`
and `i64`, nested/container option support, option equality or printing,
stable ABI/layout claims, manifest schema changes, or beta maturity.

## exp-94 (released experimental alpha)

Release label: `exp-94`

Release name: Standard Vec I64 Baseline Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_94_STANDARD_VEC_I64_BASELINE_ALPHA.md`.

exp-94 adds `std/vec_i64.slo` as the first usable source-authored `(vec i64)`
facade over the sibling concrete vec runtime family. Its public surface is:

- direct wrappers: `empty`, `append`, `len`, and `at`
- builder helpers: `singleton`, `append2`, `append3`, `pair`, and `triple`
- query helpers: `is_empty`, `index_or`, `first_or`, and `last_or`
- simple real-program helpers: `contains` and `sum`

The direct wrappers call only `std.vec.i64.empty`, `std.vec.i64.append`,
`std.vec.i64.len`, and `std.vec.i64.index`. The remaining helpers are
ordinary deterministic Slovo source helpers over that direct surface, current
control flow, integer comparison, equality, and `i64` addition. `index_or`
returns its fallback for negative and out-of-range positions, `first_or` and
`last_or` provide stable empty-vector fallbacks, `contains` returns `true`
exactly when any element equals the target, and `sum` returns `0i64` for empty
vectors.
The matching explicit import fixture, `examples/projects/std-import-vec_i64/`,
deterministically exercises the direct wrappers plus the builder, query,
contains, and sum helpers, with 6 passed tests in the explicit project
fixture. The release also adds `examples/supported/vec-i64.slo` with matching
formatter coverage in `examples/formatter/vec-i64.slo` for the raw
`std.vec.i64.*` runtime surface, vector equality, and append immutability.

exp-94 does not add generic vectors, `vec f64`, `vec string`,
option/result payload widening, automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names on the Slovo side, transform/range-edit helper families for `(vec i64)`,
mutating vec APIs, capacity or reserve management, sorting, mapping,
filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or
beta maturity.

## exp-93 (released experimental alpha)

Release label: `exp-93`

Release name: Standard Vec I32 Count-Of Helper Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_93_STANDARD_VEC_I32_COUNT_OF_HELPER_ALPHA.md`.

exp-93 extends `std/vec_i32.slo` with exactly one new public helper over the
already promoted concrete vec runtime family:

- `count_of`

This is an ordinary Slovo source function over the existing `len`, `at`,
equality, and `while` surface; it adds no new runtime calls, compiler
semantic changes, private recursive helper, or compiler-known `std.*` names.
`count_of ((values (vec i32)) (target i32)) -> i32` returns the number of
elements of `values` equal to `target`. It returns `0` for an empty vector
and when `target` is absent, counts repeated matches exactly, and leaves the
source vector unchanged. The matching explicit import fixture,
`examples/projects/std-import-vec_i32/`, deterministically exercises empty,
repeated-match, single-match, no-match, and unchanged-source cases alongside
the earlier vec helper groups, with 22 passed tests in the explicit project
fixture.

exp-93 does not add generic collections, vector payload families beyond
`(vec i32)`, slice/view types, automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, broader vec aggregation or filter families beyond
the current concrete helper surface, mutating vec APIs, capacity or reserve
management, sorting, mapping, filtering, iterators, stable
ABI/layout/ownership, optimizer guarantees, or beta maturity.

## exp-92 (released experimental alpha)

Release label: `exp-92`

Release name: Standard Vec I32 Without-Prefix Helper Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_92_STANDARD_VEC_I32_WITHOUT_PREFIX_HELPER_ALPHA.md`.

exp-92 extends `std/vec_i32.slo` with exactly one new public helper over the
already promoted concrete vec runtime family:

- `without_prefix`

This is an ordinary compositional Slovo source function over the existing
`starts_with`, `drop`, and `len` helpers; it adds no new runtime calls,
compiler semantic changes, private recursive helper, or compiler-known
`std.*` names. `without_prefix ((values (vec i32)) (prefix (vec i32))) ->
(vec i32)` removes a matching leading prefix from `values`. It returns
`values` unchanged for an empty prefix, a longer prefix, or a mismatched
prefix, returns `(empty)` when `values` exactly equals `prefix`, and leaves
both source vectors unchanged. The matching explicit import fixture,
`examples/projects/std-import-vec_i32/`, deterministically exercises empty,
exact, shorter matching, longer non-matching, mismatched, and unchanged-source
prefix cases alongside the earlier vec helper groups, with 21 passed tests in
the explicit project fixture.

exp-92 does not add generic collections, vector payload families beyond
`(vec i32)`, slice/view types, automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, broader prefix/suffix helper families beyond
`starts_with`, `without_prefix`, `ends_with`, and `without_suffix`, broader
copied subvector/range-edit helper families beyond `insert_range`,
`replace_range`, `remove_range`, `subvec`, `without_prefix`, and
`without_suffix`, mutating vec APIs, capacity or reserve management,
sorting, mapping, filtering, iterators, stable ABI/layout/ownership,
optimizer guarantees, or beta maturity.

## exp-91 (released experimental alpha)

Release label: `exp-91`

Release name: Standard Vec I32 Without-Suffix Helper Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_91_STANDARD_VEC_I32_WITHOUT_SUFFIX_HELPER_ALPHA.md`.

exp-91 extends `std/vec_i32.slo` with exactly one new public helper over the
already promoted concrete vec runtime family:

- `without_suffix`

This is an ordinary compositional Slovo source function over the existing
`ends_with`, `take`, and `len` helpers; it adds no new runtime calls,
compiler semantic changes, private recursive helper, or compiler-known
`std.*` names. `without_suffix ((values (vec i32)) (suffix (vec i32))) ->
(vec i32)` removes a matching trailing suffix from `values`. It returns
`values` unchanged for an empty suffix, a longer suffix, or a mismatched
suffix, returns `(empty)` when `values` exactly equals `suffix`, and leaves
both source vectors unchanged. The matching explicit import fixture,
`examples/projects/std-import-vec_i32/`, deterministically exercises empty,
exact, shorter matching, longer non-matching, mismatched, and unchanged-source
suffix cases alongside the earlier vec helper groups, with 20 passed tests in
the explicit project fixture.

exp-91 does not add generic collections, vector payload families beyond
`(vec i32)`, slice/view types, automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, broader prefix/suffix helper families beyond
`starts_with`, `ends_with`, and `without_suffix`, broader copied
subvector/range-edit helper families beyond `insert_range`, `replace_range`,
`remove_range`, `subvec`, and `without_suffix`, mutating vec APIs, capacity
or reserve management, sorting, mapping, filtering, iterators, stable
ABI/layout/ownership, optimizer guarantees, or beta maturity.

## exp-90 (released experimental alpha)

Release label: `exp-90`

Release name: Standard Vec I32 Ends-With Helper Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_90_STANDARD_VEC_I32_ENDS_WITH_HELPER_ALPHA.md`.

exp-90 extends `std/vec_i32.slo` with exactly one new public helper over the
already promoted concrete vec runtime family:

- `ends_with`

This is an ordinary compositional Slovo source function over the existing
`drop`, `len`, and vec equality helpers; it adds no new runtime calls,
compiler semantic changes, private recursive helper, or compiler-known
`std.*` names. `ends_with ((values (vec i32)) (suffix (vec i32))) -> bool`
returns `true` exactly when `values` ends with all elements of `suffix` in
order. It returns `true` for an empty suffix, `false` when `len(suffix) >
len(values)`, `true` for equal vectors and shorter matching suffixes, and
`false` for mismatched suffixes. The helper leaves both source vectors
unchanged. The matching explicit import fixture,
`examples/projects/std-import-vec_i32/`, deterministically exercises empty,
equal, shorter matching, longer non-matching, mismatched, and unchanged-source
suffix cases alongside the earlier vec helper groups, with 19 passed tests in
the explicit project fixture.

exp-90 does not add generic collections, vector payload families beyond
`(vec i32)`, slice/view types, automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, broader prefix/suffix query helpers beyond
`starts_with` and `ends_with`, broader copied subvector/range-edit helper
families beyond `insert_range`, `replace_range`, `remove_range`, and
`subvec`, mutating vec APIs, capacity or reserve management, sorting,
mapping, filtering, iterators, stable ABI/layout/ownership, optimizer
guarantees, or beta maturity.

## exp-89 (released experimental alpha)

Release label: `exp-89`

Release name: Standard Vec I32 Starts-With Helper Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_89_STANDARD_VEC_I32_STARTS_WITH_HELPER_ALPHA.md`.

exp-89 extends `std/vec_i32.slo` with exactly one new public helper over the
already promoted concrete vec runtime family:

- `starts_with`

This is an ordinary compositional Slovo source function over the existing
`take`, `len`, and vec equality helpers; it adds no new runtime calls,
compiler semantic changes, private recursive helper, or compiler-known
`std.*` names. `starts_with ((values (vec i32)) (prefix (vec i32))) -> bool`
returns `true` exactly when `values` begins with all elements of `prefix` in
order. It returns `true` for an empty prefix, `false` when `len(prefix) >
len(values)`, `true` for equal vectors and shorter matching prefixes, and
`false` for mismatched prefixes. The helper leaves both source vectors
unchanged. The matching explicit import fixture,
`examples/projects/std-import-vec_i32/`, deterministically exercises empty,
equal, shorter matching, longer non-matching, mismatched, and unchanged-source
cases alongside the earlier vec helper groups, with 18 passed tests in the
explicit project fixture.

exp-89 does not add generic collections, vector payload families beyond
`(vec i32)`, slice/view types, automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, broader prefix/suffix query helpers beyond
`starts_with`, broader copied subvector/range-edit helper families beyond
`insert_range`, `replace_range`, `remove_range`, and `subvec`, mutating vec
APIs, capacity or reserve management, sorting, mapping, filtering,
iterators, stable ABI/layout/ownership, optimizer guarantees, or beta
maturity.

## exp-88 (released experimental alpha)

Release label: `exp-88`

Release name: Standard Vec I32 Replace Range Helper Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_88_STANDARD_VEC_I32_REPLACE_RANGE_HELPER_ALPHA.md`.

exp-88 extends `std/vec_i32.slo` with exactly one new public helper over the
already promoted concrete vec runtime family:

- `replace_range`

This is an ordinary compositional Slovo source function over the existing
`take`, `drop`, and `concat` vec helpers; it adds no new runtime calls,
compiler semantic changes, private recursive helper, or compiler-known
`std.*` names. `replace_range ((values (vec i32)) (start i32)
(end_exclusive i32) (replacement (vec i32))) -> (vec i32)` replaces the
half-open range `[start, end_exclusive)` with all of `replacement` when the
start is valid. If `start < 0`, `end_exclusive <= start`, or
`start >= len(values)`, it returns `values` unchanged. If
`end_exclusive >= len(values)`, it replaces the tail from `start`. The
helper preserves prefix order, then replacement order, then surviving suffix
order, and does not mutate either source vector. The matching explicit
import fixture, `examples/projects/std-import-vec_i32/`, deterministically
exercises middle replacement, tail replacement, unchanged invalid-range,
unchanged-source-vector, unchanged-replacement-vector, and preserved-order
cases alongside the earlier vec helper groups, with 17 passed tests in the
explicit project fixture.

exp-88 does not add generic collections, vector payload families beyond
`(vec i32)`, slice/view types, automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, 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 or reserve management, sorting,
mapping, filtering, iterators, stable ABI/layout/ownership, optimizer
guarantees, or beta maturity.

## exp-87 (released experimental alpha)

Release label: `exp-87`

Release name: Standard Vec I32 Insert Range Helper Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_87_STANDARD_VEC_I32_INSERT_RANGE_HELPER_ALPHA.md`.

exp-87 extends `std/vec_i32.slo` with exactly one new public helper over the
already promoted concrete vec runtime family:

- `insert_range`

This is an ordinary compositional Slovo source function over the existing
`take`, `drop`, and `concat` vec helpers; it adds no new runtime calls,
compiler semantic changes, private recursive helper, or compiler-known
`std.*` names. `insert_range ((values (vec i32)) (position i32)
(inserted (vec i32))) -> (vec i32)` returns a new vector when `position` is
valid: if `0 <= position < len(values)`, it inserts all of `inserted` before
the current element at `position`, and if `position == len(values)`, it
appends `inserted` at the end. The result length is then
`len(values) + len(inserted)`. If `position < 0` or `position > len(values)`,
it returns `values` unchanged. The helper preserves the order of both
vectors and does not mutate either source vector. The matching explicit
import fixture, `examples/projects/std-import-vec_i32/`, deterministically
exercises middle insertion, append-at-end insertion, negative-position,
out-of-range-position, and unchanged-source-vector cases alongside the
earlier vec helper groups.

exp-87 does not add generic collections, vector payload families beyond
`(vec i32)`, slice/view types, automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, 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 or
reserve management, sorting, mapping, filtering, iterators, stable
ABI/layout/ownership, optimizer guarantees, or beta maturity.

## exp-86 (released experimental alpha)

Release label: `exp-86`

Release name: Standard Vec I32 Remove Range Helper Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_86_STANDARD_VEC_I32_REMOVE_RANGE_HELPER_ALPHA.md`.

exp-86 extends `std/vec_i32.slo` with exactly one new public helper over the
already promoted concrete vec runtime family:

- `remove_range`

This is an ordinary compositional Slovo source function over the existing
`take`, `drop`, and `concat` vec helpers; it adds no new runtime calls,
compiler semantic changes, private recursive helper, or compiler-known
`std.*` names. `remove_range ((values (vec i32)) (start i32)
(end_exclusive i32)) -> (vec i32)` removes the half-open range
`[start, end_exclusive)` from `values` while preserving the order of the
remaining elements. If `start < 0`, `end_exclusive <= start`, or
`start >= len(values)`, it returns `values` unchanged. If
`end_exclusive >= len(values)`, it removes the tail from `start`. The helper
leaves the source vector unchanged. The matching explicit import fixture,
`examples/projects/std-import-vec_i32/`, deterministically exercises
middle-range removal, tail removal, `end_exclusive <= start`,
out-of-range-start, negative-start, and unchanged-source cases alongside the
earlier vec helper groups.

exp-86 does not add generic collections, vector payload families beyond
`(vec i32)`, slice/view types, automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, 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 or reserve management, sorting, mapping,
filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or
beta maturity.

## exp-85 (released experimental alpha)

Release label: `exp-85`

Release name: Standard Vec I32 Subvec Helper Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_85_STANDARD_VEC_I32_SUBVEC_HELPER_ALPHA.md`.

exp-85 extends `std/vec_i32.slo` with exactly one new public helper over the
already promoted concrete vec runtime family:

- `subvec`

This is an ordinary compositional Slovo source function over the existing
`take` and `drop` vec helpers; it adds no new runtime calls, compiler
semantic changes, private recursive helper, or compiler-known `std.*` names.
`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)`, it returns
`(empty)`. If `end_exclusive > len(values)`, it returns the remaining tail
from `start`. The helper preserves source order, leaves the source vector
unchanged, and remains an ordinary copied vec helper rather than a slice/view
type. The matching explicit import fixture,
`examples/projects/std-import-vec_i32/`, deterministically exercises
middle-range, tail-truncation, empty-range, out-of-range, negative-start,
and unchanged-source cases alongside the earlier vec helper groups.

exp-85 does not add generic collections, vector payload families beyond
`(vec i32)`, slice/view types, automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, broader copied subvector/window helpers beyond
`subvec`, public insert/remove/edit families beyond `subvec`, `insert_at`,
`replace_at`, and `remove_at`, mutating vec APIs, capacity or reserve
management, sorting, mapping, filtering, iterators, stable
ABI/layout/ownership, optimizer guarantees, or beta maturity.

## exp-84 (released experimental alpha)

Release label: `exp-84`

Release name: Standard Vec I32 Insert Helper Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_84_STANDARD_VEC_I32_INSERT_HELPER_ALPHA.md`.

exp-84 extends `std/vec_i32.slo` with exactly one new public helper over the
already promoted concrete vec runtime family:

- `insert_at`

This is an ordinary compositional Slovo source function over the existing
`append`, `take`, `drop`, and `concat` vec helpers; it adds no new runtime
calls, compiler semantic changes, private recursive helper, or compiler-known
`std.*` names. `insert_at ((values (vec i32)) (position i32) (value i32)) ->
(vec i32)` returns a new vector when `position` is valid: if
`0 <= position < len(values)`, it inserts `value` before the current element
at `position`, and if `position == len(values)`, it appends `value` at the
end. The result length is then `len(values) + 1`. If `position < 0` or
`position > len(values)`, it returns `values` unchanged. The helper does not
mutate the source vector. The matching explicit import fixture,
`examples/projects/std-import-vec_i32/`, deterministically exercises
middle-insert, append-at-end, negative, and out-of-range insertion cases
alongside the earlier vec helper groups.

exp-84 does not add generic collections, vector payload families beyond
`(vec i32)`, slice types, automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, public insert/remove/edit families beyond
`insert_at`, `replace_at`, and `remove_at`, mutating vec APIs, capacity or
reserve management, sorting, mapping, filtering, iterators, stable
ABI/layout/ownership, optimizer guarantees, or beta maturity.

## exp-83 (released experimental alpha)

Release label: `exp-83`

Release name: Standard Vec I32 Remove Helper Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_83_STANDARD_VEC_I32_REMOVE_HELPER_ALPHA.md`.

exp-83 extends `std/vec_i32.slo` with exactly one new public helper over the
already promoted concrete vec runtime family:

- `remove_at`

This is an ordinary compositional Slovo source function over the existing
`take`, `drop`, and `concat` vec helpers; it adds no new runtime calls,
compiler semantic changes, private recursive helper, or compiler-known
`std.*` names. `remove_at ((values (vec i32)) (position i32)) -> (vec i32)`
returns a new vector with the element at `position` removed when
`0 <= position < len(values)`, preserving the order of the remaining
elements. The result length is then `len(values) - 1`. If `position < 0` or
`position >= len(values)`, it returns `values` unchanged. The helper does not
mutate the source vector. The matching explicit import fixture,
`examples/projects/std-import-vec_i32/`, deterministically exercises
in-range, negative, and out-of-range removal cases alongside the earlier vec
helper groups.

exp-83 does not add generic collections, vector payload families beyond
`(vec i32)`, slice types, automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, public insert/remove/edit families beyond
`replace_at` and `remove_at`, mutating vec APIs, capacity or reserve
management, sorting, mapping, filtering, iterators, stable
ABI/layout/ownership, optimizer guarantees, or beta maturity.

## exp-82 (released experimental alpha)

Release label: `exp-82`

Release name: Standard Vec I32 Replace Helper Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_82_STANDARD_VEC_I32_REPLACE_HELPER_ALPHA.md`.

exp-82 extends `std/vec_i32.slo` with exactly one new public helper over the
already promoted concrete vec runtime family:

- `replace_at`

This is an ordinary compositional Slovo source function over the existing
`append`, `take`, `drop`, and `concat` vec helpers; it adds no new runtime
calls, compiler semantic changes, or compiler-known `std.*` names.
`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)`, it returns `values` unchanged. The helper does not
mutate the source vector. The matching explicit import fixture,
`examples/projects/std-import-vec_i32/`, deterministically exercises in-range,
negative, and out-of-range replacement cases alongside the earlier vec helper
groups.

exp-82 does not add generic collections, vector payload families beyond
`(vec i32)`, slice types, automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, public insert/remove/edit families beyond
`replace_at`, mutating vec APIs, capacity or reserve management, sorting,
mapping, filtering, iterators, stable ABI/layout/ownership, optimizer
guarantees, or beta maturity.

## exp-81 (released experimental alpha)

Release label: `exp-81`

Release name: Standard Vec I32 Range Helper Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_81_STANDARD_VEC_I32_RANGE_HELPER_ALPHA.md`.

exp-81 extends `std/vec_i32.slo` with exactly one new public helper over the
already promoted concrete vec runtime family:

- `range`

This is an ordinary Slovo source function over the existing `append` and
`empty` vec facade operations, with private recursive generation only.
`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 it returns an empty vector when
`end_exclusive <= start`. `range_from_zero` remains public and may delegate
to `range 0 count`. The matching explicit import fixture,
`examples/projects/std-import-vec_i32/`, deterministically exercises
negative, empty, and positive ascending range cases alongside the earlier
vec helper groups.

exp-81 does not add generic collections, vector payload families beyond
`(vec i32)`, slice types, automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, descending or stepped range variants, inclusive
range variants, edit helpers, mutating vec APIs, capacity or reserve
management, sorting, mapping, filtering, iterators, stable
ABI/layout/ownership, optimizer guarantees, or beta maturity.

## exp-80 (released experimental alpha)

Release label: `exp-80`

Release name: Standard Vec I32 Generated Constructor Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_80_STANDARD_VEC_I32_GENERATED_CONSTRUCTOR_HELPERS_ALPHA.md`.

exp-80 extends `std/vec_i32.slo` with narrow generated constructor helpers
over the already promoted concrete vec runtime family:

- `repeat`
- `range_from_zero`

These are ordinary Slovo source functions over the existing `append` and
`empty` vec facade operations. `repeat` returns an empty vector when
`count <= 0`. `range_from_zero` produces `0`, `1`, and so on up to but
excluding `count`, and returns an empty vector when `count <= 0`. The
matching explicit import fixture, `examples/projects/std-import-vec_i32/`,
now deterministically exercises this constructor helper group alongside the
earlier direct, builder, fallback query, option-query, transform, and
real-program vec helpers.

exp-80 does not add generic collections, vector payload families beyond
`(vec i32)`, slice types, automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, mutating vec APIs, capacity or reserve
management, public `range`, descending or stepped range variants, inclusive
range variants, edit helpers, sorting, mapping, filtering, iterators, stable
ABI/layout/ownership,
optimizer guarantees, or beta maturity.

## exp-79 (released experimental alpha)

Release label: `exp-79`

Release name: Standard Vec I32 Transform Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_79_STANDARD_VEC_I32_TRANSFORM_HELPERS_ALPHA.md`.

exp-79 extends `std/vec_i32.slo` with narrow transform helpers over the
already promoted concrete vec runtime family:

- `concat`
- `take`
- `drop`
- `reverse`

These are ordinary Slovo source functions over the existing `append`, `len`,
`at`, and `empty` vec facade operations. `concat`, `take`, `drop`, and
`reverse` are expressed with private recursive helpers instead of mutable vec
locals. Negative counts behave as zero; `take` returns the original vector
when the requested count reaches or exceeds the current length, and `drop`
returns an empty vector in that same case. The matching explicit import
fixture, `examples/projects/std-import-vec_i32/`, now deterministically
exercises this transform helper group alongside the earlier direct, builder,
fallback query, option-query, and real-program vec helpers.

exp-79 does not add generic collections, vector payload families beyond
`(vec i32)`, slice types, automatic standard-library imports,
compiler-loaded standard-library source, new compiler-known `std.*` runtime
names, mutable vec locals, mutating vec APIs, capacity or reserve
management, sorting, mapping, filtering, iterators, stable
ABI/layout/ownership, optimizer guarantees, or beta maturity.

## exp-78 (released experimental alpha)

Release label: `exp-78`

Release name: Standard CLI Local Source Facade Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_78_STANDARD_CLI_LOCAL_SOURCE_FACADE_ALPHA.md`.

exp-78 records the staged `std/cli.slo` facade as the Slovo-side contract for
the sibling Glagol local-source gate without widening the `std.cli` helper
surface. `std/cli.slo` itself remains unchanged for this release, and the
released helper list stays:

- `arg_text_result`
- `arg_i32_result`
- `arg_i32_or_zero`
- `arg_i32_or`
- `arg_i64_result`
- `arg_i64_or_zero`
- `arg_i64_or`
- `arg_f64_result`
- `arg_f64_or_zero`
- `arg_f64_or`
- `arg_bool_result`
- `arg_bool_or_false`
- `arg_bool_or`

The facade remains ordinary Slovo source over existing `std.process` and
`std.string` surface only, with no additional standard-source dependencies.
The existing explicit import fixture, `examples/projects/std-import-cli/`,
remains valid, and the paired Glagol local-source gate is expected to mirror
the same composition pattern.

exp-78 does not add new `std.cli` helpers, automatic standard-library
imports, compiler-loaded standard-library source, a `std.slo` aggregator,
package std dependency syntax, new compiler-known `std.*` runtime names,
process spawning, exit/status control, current-directory APIs, signal
handling, shell parsing, option or flag parsing, subcommands,
environment-backed configuration, richer CLI framework APIs, stable
ABI/layout/ownership, optimizer guarantees, or beta maturity.

## exp-77 (released experimental alpha)

Release label: `exp-77`

Release name: Standard Vec I32 Option Query Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_77_STANDARD_VEC_I32_OPTION_QUERY_HELPERS_ALPHA.md`.

exp-77 extends `std/vec_i32.slo` with concrete option-returning query helpers
over the already promoted concrete vec runtime family:

- `index_option`
- `first_option`
- `last_option`
- `index_of_option`
- `last_index_of_option`

These are ordinary Slovo source functions over the existing `len`, `at`, and
`while` vec facade operations plus `std.option.some_i32` and
`std.option.none_i32`. The matching explicit import fixture,
`examples/projects/std-import-vec_i32/`, now deterministically exercises this
option-query helper group alongside the earlier direct, builder, fallback
query, and real-program vec helpers.

exp-77 does not add generic collections, vector payload families beyond
`(vec i32)`, option payload families beyond `(option i32)`, automatic
standard-library imports, compiler-loaded standard-library source, new
compiler-known `std.*` runtime names, mutating vec APIs, capacity or reserve
management, sorting, mapping, filtering, iterators, stable
ABI/layout/ownership, optimizer guarantees, or beta maturity.

## exp-76 (released experimental alpha)

Release label: `exp-76`

Release name: Standard Vec I32 Source Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_76_STANDARD_VEC_I32_SOURCE_HELPERS_ALPHA.md`.

exp-76 extends `std/vec_i32.slo` with a concrete `(vec i32)` source-authored
collection facade over the already promoted `std.vec.i32` runtime family:

- direct wrappers:
  - `empty`
  - `append`
  - `len`
  - `at`
- builder helpers:
  - `singleton`
  - `append2`
  - `append3`
  - `pair`
  - `triple`
- query helpers:
  - `is_empty`
  - `index_or`
  - `first_or`
  - `last_or`
- real-program helpers:
  - `contains`
  - `sum`

These are ordinary Slovo source functions over the existing vector runtime
calls plus simple source `while` loops. The matching explicit import fixture,
`examples/projects/std-import-vec_i32/`, now exercises the direct facade and
the staged helper groups through explicit `std.vec_i32` imports.

exp-76 does not add generic vectors, vector payload families beyond
`(vec i32)`, automatic standard-library imports, compiler-loaded
standard-library source, capacity or reserve management, push/pop helpers,
sorting, mapping, filtering, iterators, new compiler-known `std.*` runtime
names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity.

## exp-75 (released experimental alpha)

Release label: `exp-75`

Release name: Standard Option Constructors Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_75_STANDARD_OPTION_CONSTRUCTORS_ALPHA.md`.

exp-75 extends `std/option.slo` with concrete source constructors for the
currently promoted `(option i32)` family:

- `some_i32`
- `none_i32`

These are ordinary Slovo source functions over the existing `some` and
`none` forms, fixed to the current released `(option i32)` family. The
matching explicit import fixture, `examples/projects/std-import-option/`, now
uses those constructors instead of repeating raw typed `some` and `none`
forms.

exp-75 does not add generic option helpers, new option payload families,
automatic standard-library imports, compiler-loaded standard-library source,
new compiler-known `std.*` runtime names, stable ABI/layout/ownership,
optimizer guarantees, or beta maturity.

## exp-74 (released experimental alpha)

Release label: `exp-74`

Release name: Standard Result Constructor Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_74_STANDARD_RESULT_CONSTRUCTOR_HELPERS_ALPHA.md`.

exp-74 extends `std/result.slo` with concrete source constructors for the
currently promoted result families:

- `ok_i32`
- `err_i32`
- `ok_i64`
- `err_i64`
- `ok_string`
- `err_string`
- `ok_f64`
- `err_f64`
- `ok_bool`
- `err_bool`

These are ordinary Slovo source functions over the existing `ok` and `err`
forms, fixed to the current released `(result <payload> i32)` families. The
matching explicit import fixture, `examples/projects/std-import-result/`, now
uses those constructors instead of repeating raw typed `ok` and `err` forms.

exp-74 does not add generic result helpers, new result payload families,
generic `map`/`and_then`, richer error ADTs, automatic standard-library
imports, compiler-loaded standard-library source, new compiler-known `std.*`
runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta
maturity.

## exp-73 (released experimental alpha)

Release label: `exp-73`

Release name: Standard Io Value Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_73_STANDARD_IO_VALUE_HELPERS_ALPHA.md`.

exp-73 extends `std/io.slo` with source-authored value-returning print
helpers over the already promoted print runtime calls:

- `print_i32_value`
- `print_i64_value`
- `print_f64_value`
- `print_string_value`
- `print_bool_value`

These are ordinary Slovo source functions over `std.io.print_i32`,
`std.io.print_i64`, `std.io.print_f64`, `std.io.print_string`, and
`std.io.print_bool`, followed by returning the original value. The matching
explicit import fixture, `examples/projects/std-import-io/`, now exercises
both the earlier zero-returning wrappers and the new value-preserving cases.

exp-73 does not add automatic standard-library imports, compiler-loaded
standard-library source, stderr facade helpers, stdin facade helpers, line
iteration, prompt APIs, terminal control, binary IO, streaming IO, async IO,
new compiler-known `std.*` runtime names, stable ABI/layout/ownership,
optimizer guarantees, or beta maturity.

## exp-72 (released experimental alpha)

Release label: `exp-72`

Release name: Standard Cli Custom Fallback Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_72_STANDARD_CLI_CUSTOM_FALLBACK_HELPERS_ALPHA.md`.

exp-72 extends `std/cli.slo` with source-authored typed argument
custom-fallback helpers over the already promoted argument lookup and concrete
parse result families:

- `arg_i32_or`
- `arg_i64_or`
- `arg_f64_or`
- `arg_bool_or`

These are ordinary Slovo source functions over `arg_result`,
`parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and
`parse_bool_result` plus source `match`. The matching explicit import
fixture, `examples/projects/std-import-cli/`, now exercises both the earlier
zero/false fallbacks and the new typed custom-fallback cases.

exp-72 does not add automatic standard-library imports, compiler-loaded
standard-library source, process spawning, exit/status control, current
directory APIs, signal handling, shell parsing, subcommands, richer CLI
framework APIs, generic configuration helpers, new compiler-known `std.*`
runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta
maturity.

## exp-71 (released experimental alpha)

## exp-71 (released experimental alpha)

Release label: `exp-71`

Release name: Standard Process Custom Fallback Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_71_STANDARD_PROCESS_CUSTOM_FALLBACK_HELPERS_ALPHA.md`.

exp-71 extends `std/process.slo` with source-authored typed argument
custom-fallback helpers over the already promoted argument lookup and concrete
parse result families:

- `arg_i32_or`
- `arg_i64_or`
- `arg_f64_or`
- `arg_bool_or`

These are ordinary Slovo source functions over `arg_result`,
`parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and
`parse_bool_result` plus source `match`. The matching explicit import
fixture, `examples/projects/std-import-process/`, now exercises both the
earlier zero/false fallbacks and the new typed custom-fallback cases.

exp-71 does not add automatic standard-library imports, compiler-loaded
standard-library source, process spawning, exit/status control, current
directory APIs, signal handling, shell parsing, subcommands, richer CLI
framework APIs, generic configuration helpers, new compiler-known `std.*`
runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta
maturity.

## exp-70 (released experimental alpha)

## exp-70 (released experimental alpha)

Release label: `exp-70`

Release name: Standard Fs Custom Fallback Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_70_STANDARD_FS_CUSTOM_FALLBACK_HELPERS_ALPHA.md`.

exp-70 extends `std/fs.slo` with source-authored typed read custom-fallback
helpers over the already promoted text-read and concrete parse result
families:

- `read_i32_or`
- `read_i64_or`
- `read_f64_or`
- `read_bool_or`

These are ordinary Slovo source functions over `read_text_result`,
`parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and
`parse_bool_result` plus source `match`. The matching explicit import
fixture, `examples/projects/std-import-fs/`, now exercises both the earlier
zero/false fallbacks and the new typed custom-fallback cases.

exp-70 does not add automatic standard-library imports, compiler-loaded
standard-library source, binary file APIs, directory traversal, streaming
file IO, async file IO, typed file writes, rich host errors, new
compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer
guarantees, or beta maturity.

## exp-69 (released experimental alpha)

## exp-69 (released experimental alpha)

Release label: `exp-69`

Release name: Standard Env Custom Fallback Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_69_STANDARD_ENV_CUSTOM_FALLBACK_HELPERS_ALPHA.md`.

exp-69 extends `std/env.slo` with source-authored typed parse
custom-fallback helpers over the already promoted environment lookup and
concrete parse result families:

- `get_i32_or`
- `get_i64_or`
- `get_f64_or`
- `get_bool_or`

These are ordinary Slovo source functions over `get_result`,
`parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and
`parse_bool_result` plus source `match`. The matching explicit import
fixture, `examples/projects/std-import-env/`, now exercises both the earlier
zero/false fallbacks and the new typed custom-fallback cases.

exp-69 does not add automatic standard-library imports, compiler-loaded
standard-library source, generic configuration helpers, environment mutation,
environment enumeration, environment writes, rich host errors, new
compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer
guarantees, or beta maturity.

## exp-68 (released experimental alpha)

Release label: `exp-68`

Release name: Standard String Custom Fallback Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_68_STANDARD_STRING_CUSTOM_FALLBACK_HELPERS_ALPHA.md`.

exp-68 extends `std/string.slo` with source-authored typed parse
custom-fallback helpers over the already promoted concrete parse result
families:

- `parse_i32_or`
- `parse_i64_or`
- `parse_f64_or`
- `parse_bool_or`

These are ordinary Slovo source functions over `parse_i32_result`,
`parse_i64_result`, `parse_f64_result`, and `parse_bool_result` plus source
`match`. The matching explicit import fixture,
`examples/projects/std-import-string/`, now exercises both the earlier
zero/false fallbacks and the new typed custom-fallback cases.

exp-68 does not add automatic standard-library imports, compiler-loaded
standard-library source, generic parse helpers, whitespace trimming,
case-insensitive bool parsing, rich parse errors, new compiler-known `std.*`
runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta
maturity.

## exp-67 (released experimental alpha)

Release label: `exp-67`

Release name: Standard Process Typed Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_67_STANDARD_PROCESS_TYPED_HELPERS_ALPHA.md`.

exp-67 extends `std/process.slo` with source-authored typed argument
result/fallback helpers over process arguments plus the already promoted
concrete parse result families:

- `arg_i32_result`
- `arg_i32_or_zero`
- `arg_i64_result`
- `arg_i64_or_zero`
- `arg_f64_result`
- `arg_f64_or_zero`
- `arg_bool_result`
- `arg_bool_or_false`

These are ordinary Slovo source functions over `arg_result`,
`parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and
`parse_bool_result` plus source `match`. The matching explicit import
fixture, `examples/projects/std-import-process/`, now exercises the existing
process wrappers, deterministic missing-argument cases, and deterministic
invalid-present fallback behavior through `arg 0`.

exp-67 does not add automatic standard-library imports, compiler-loaded
standard-library source, process spawning, exit/status control, current
directory APIs, shell parsing, subcommands, richer CLI framework APIs, rich
host errors, new compiler-known `std.*` runtime names, stable
ABI/layout/ownership, optimizer guarantees, or beta maturity.

## exp-66 (released experimental alpha)

Release label: `exp-66`

Release name: Standard Fs Typed Read Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_66_STANDARD_FS_TYPED_READ_HELPERS_ALPHA.md`.

exp-66 extends `std/fs.slo` with source-authored typed read
result/fallback helpers over text-file reads plus the already promoted
concrete parse result families:

- `read_i32_result`
- `read_i32_or_zero`
- `read_i64_result`
- `read_i64_or_zero`
- `read_f64_result`
- `read_f64_or_zero`
- `read_bool_result`
- `read_bool_or_false`

These are ordinary Slovo source functions over `read_text_result`,
`parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and
`parse_bool_result` plus source `match`. The matching explicit import
fixture, `examples/projects/std-import-fs/`, now exercises the existing fs
wrappers, typed parse success cases, and deterministic invalid/missing
fallback behavior.

exp-66 does not add automatic standard-library imports, compiler-loaded
standard-library source, binary file APIs, directory traversal, streaming
file IO, async file IO, typed file writes, rich host errors, generic
configuration helpers, new compiler-known `std.*` runtime names, stable
ABI/layout/ownership, optimizer guarantees, or beta maturity.

## exp-65 (released experimental alpha)

Release label: `exp-65`

Release name: Standard Env Typed Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_65_STANDARD_ENV_TYPED_HELPERS_ALPHA.md`.

exp-65 extends `std/env.slo` with source-authored typed parse
result/fallback helpers over environment lookup plus the already promoted
concrete parse result families:

- `get_i32_result`
- `get_i32_or_zero`
- `get_i64_result`
- `get_i64_or_zero`
- `get_f64_result`
- `get_f64_or_zero`
- `get_bool_result`
- `get_bool_or_false`

These are ordinary Slovo source functions over `get_result`,
`parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and
`parse_bool_result` plus source `match`. The matching explicit import
fixture, `examples/projects/std-import-env/`, now exercises the existing env
wrappers, typed parse success cases, and deterministic invalid/missing
fallback behavior.

exp-65 does not add automatic standard-library imports, compiler-loaded
standard-library source, environment mutation, environment enumeration,
environment writes, rich host errors, generic configuration helpers, new
compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer
guarantees, or beta maturity.

## exp-64 (released experimental alpha)

Release label: `exp-64`

Release name: Standard Num Fallback Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_64_STANDARD_NUM_FALLBACK_HELPERS_ALPHA.md`.

exp-64 extends `std/num.slo` with source-authored checked conversion
fallback helpers over the already promoted numeric result families:

- `i64_to_i32_or`
- `f64_to_i32_or`
- `f64_to_i64_or`

These are ordinary Slovo source functions over `i64_to_i32_result`,
`f64_to_i32_result`, and `f64_to_i64_result` plus source `match`. The
matching explicit import fixture, `examples/projects/std-import-num/`, now
exercises both the existing conversion wrappers and the new fallback helpers.

exp-64 does not add automatic standard-library imports, compiler-loaded
standard-library source, unchecked narrowing conversions, saturating
conversions, generic numeric traits, new compiler-known `std.*` runtime
names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity.

## exp-63 (released experimental alpha)

Release label: `exp-63`

Release name: Standard Fs Fallback Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_63_STANDARD_FS_FALLBACK_HELPERS_ALPHA.md`.

exp-63 extends `std/fs.slo` with source-authored text fallback/status
helpers over the already promoted filesystem result families:

- `read_text_or`
- `write_text_ok`

These are ordinary Slovo source functions over `read_text_result` and
`write_text_result` plus source `match`. The matching explicit import fixture,
`examples/projects/std-import-fs/`, now exercises both the existing fs
wrappers and the new fallback/status helpers.

exp-63 does not add automatic standard-library imports, compiler-loaded
standard-library source, binary file APIs, directory traversal, streaming
file IO, async file IO, rich host errors, new compiler-known `std.*` runtime
names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity.

## exp-62 (released experimental alpha)

Release label: `exp-62`

Release name: Standard Env Fallback Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_62_STANDARD_ENV_FALLBACK_HELPERS_ALPHA.md`.

exp-62 extends `std/env.slo` with source-authored environment fallback
helpers over the already promoted `(result string i32)` environment lookup
family:

- `has`
- `get_or`

These are ordinary Slovo source functions over `get_result` plus source
`match`. The matching explicit import fixture,
`examples/projects/std-import-env/`, now exercises both the existing env
wrappers and the new presence/fallback helpers.

exp-62 does not add automatic standard-library imports, compiler-loaded
standard-library source, environment mutation, environment enumeration,
platform/configuration APIs, rich host errors, new compiler-known `std.*`
runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta
maturity.

## exp-61 (released experimental alpha)

Release label: `exp-61`

Release name: Standard Process Fallback Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_61_STANDARD_PROCESS_FALLBACK_HELPERS_ALPHA.md`.

exp-61 extends `std/process.slo` with source-authored fallback helpers over
the already promoted `(result string i32)` process argument family:

- `arg_or`
- `arg_or_empty`

These are ordinary Slovo source functions over `arg_result` plus source
`match`. The matching explicit import fixture,
`examples/projects/std-import-process/`, now exercises both the existing
process wrappers and the new fallback helpers.

exp-61 does not add automatic standard-library imports, compiler-loaded
standard-library source, option/flag parsing, subcommands, process spawning,
exit/status control, shell parsing, rich host errors, new compiler-known
`std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or
beta maturity.

## exp-60 (released experimental alpha)

Release label: `exp-60`

Release name: Standard String Fallback Helpers Alpha

Release date: 2026-05-20

Status: released experimental alpha stdlib/source contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_60_STANDARD_STRING_FALLBACK_HELPERS_ALPHA.md`.

exp-60 extends `std/string.slo` with source-authored fallback helpers over
the already promoted concrete parse result families:

- `parse_i32_or_zero`
- `parse_i64_or_zero`
- `parse_f64_or_zero`
- `parse_bool_or_false`

These are ordinary Slovo source functions over the existing `parse_*_result`
helpers plus source `match` on the concrete `i32`, `i64`, `f64`, and `bool`
result families. The matching explicit import fixture,
`examples/projects/std-import-string/`, now exercises both the direct parse
result wrappers and the new fallback helpers.

exp-60 does not add automatic standard-library imports, compiler-loaded
standard-library source, generic parse helpers, whitespace trimming,
case-insensitive bool parsing, rich parse errors, new compiler-known
`std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or
beta maturity.

## exp-59 (released experimental alpha)

Release label: `exp-59`

Release name: Hosted Build Optimization And Benchmark Publication Alpha

Release date: 2026-05-20

Status: released experimental alpha documentation/tooling contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_59_HOSTED_BUILD_OPTIMIZATION_AND_BENCHMARK_PUBLICATION_ALPHA.md`.

exp-59 does not change the exp-58 source-language surface. It records the
paired Glagol exp-59 hosted-build optimization, refreshes the then-current
benchmark methodology and local benchmark evidence, and adds a repo-local PDF
rendering script for the whitepaper and manifest artifacts.

exp-59 does not add source syntax, type forms, standard-library APIs, stable
ABI/layout/ownership, optimizer guarantees, benchmark thresholds,
cross-machine performance claims, package registry behavior, or beta
maturity.

## exp-58 (released experimental alpha)

Release label: `exp-58`

Release name: Boolean Logic Alpha

Release date: 2026-05-19

Status: released experimental alpha language contract. This is experimental
maturity and not a beta maturity claim.

The normative release contract is `.llm/EXP_58_BOOLEAN_LOGIC_ALPHA.md`.

exp-58 promotes `(and left right)`, `(or left right)`, and `(not value)` for
boolean values. `and` and `or` lower through existing `if` semantics, so they
short-circuit in the deterministic test runner and hosted lowering.

The new supported fixture is `examples/supported/boolean-logic.slo`, with
matching formatter coverage in `examples/formatter/boolean-logic.slo`.

exp-58 does not add truthiness, variadic boolean operators, pattern guards,
macro expansion, stable ABI/layout/ownership, optimizer guarantees, benchmark
thresholds, or beta maturity.

## exp-57 (released experimental alpha)

Release label: `exp-57`

Release name: Integer Bitwise Alpha

Release date: 2026-05-19

Status: released experimental alpha language/stdlib contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is `.llm/EXP_57_INTEGER_BITWISE_ALPHA.md`.

exp-57 promotes explicit `bit_and`, `bit_or`, and `bit_xor` binary heads for
same-width signed integer operands: `i32` with `i32`, and `i64` with `i64`.

The release also extends `std/math.slo` with `bit_and_i32`, `bit_or_i32`,
`bit_xor_i32`, `bit_and_i64`, `bit_or_i64`, and `bit_xor_i64`.

The new supported fixture is `examples/supported/integer-bitwise.slo`, with
matching formatter coverage in `examples/formatter/integer-bitwise.slo`.

exp-57 does not add shifts, bit-not, unsigned arithmetic,
bit-width-specific integer families, floating-point bitwise operations,
generic math, mixed numeric arithmetic, stable ABI/layout/ownership,
optimizer guarantees, benchmark thresholds, or beta maturity.

## exp-56 (released experimental alpha)

Release label: `exp-56`

Release name: Integer Remainder Alpha

Release date: 2026-05-19

Status: released experimental alpha language/stdlib contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is `.llm/EXP_56_INTEGER_REMAINDER_ALPHA.md`.

exp-56 promotes the `%` binary operator for same-width signed integer
operands: `i32 % i32 -> i32` and `i64 % i64 -> i64`. The deterministic
fixture covers positive and negative dividends for both widths.

The release also extends `std/math.slo` with `rem_i32`, `is_even_i32`,
`is_odd_i32`, `rem_i64`, `is_even_i64`, and `is_odd_i64`.

The new supported fixture is `examples/supported/integer-remainder.slo`, with
matching formatter coverage in `examples/formatter/integer-remainder.slo`.

exp-56 does not add floating-point remainder, Euclidean modulo, unsigned
arithmetic, bit operations, generic math, mixed numeric arithmetic, stable
ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta
maturity.

## exp-55 (released experimental alpha)

Release label: `exp-55`

Release name: Result F64 Bool Source Flow Alpha

Release date: 2026-05-19

Status: released experimental alpha language/tooling contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_55_RESULT_F64_BOOL_SOURCE_FLOW_ALPHA.md`.

exp-55 promotes source constructors and source `match` payload bindings for
the already existing concrete `(result f64 i32)` and `(result bool i32)`
families. It also lets `std/cli.slo` propagate missing argument indexes as
`err 1` for `arg_f64_result` and `arg_bool_result`.

The new supported fixture is
`examples/supported/result-f64-bool-match.slo`.

exp-55 does not add generic result types, result payload families beyond the
already promoted concrete families, generic `map`/`and_then`, exception
handling, automatic standard-library imports, stable ABI/layout/ownership,
optimizer guarantees, benchmark thresholds, or beta maturity.

## exp-54 (released experimental alpha)

Release label: `exp-54`

Release name: Standard CLI Typed Arguments Alpha

Release date: 2026-05-19

Status: released experimental alpha language/tooling contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_54_STANDARD_CLI_TYPED_ARGUMENTS_ALPHA.md`.

exp-54 extends `std/cli.slo` with `i64`, `f64`, and `bool` typed argument
parse helpers while keeping the facade source-authored. The matching fixture
imports the expanded `std.cli` helper list explicitly without a local copied
module.

`arg_i64_result` and `arg_i64_or_zero` propagate missing argument indexes
through current source-supported result constructors. `arg_f64_result` and
`arg_bool_result` return parse results over `std.process.arg`, so
out-of-range argument indexes still follow the existing trap behavior.

exp-54 does not add automatic standard-library imports, a `std.slo`
aggregator, package registry behavior, lockfiles, package std dependencies,
new compiler-known runtime names, `err f64 i32` or `err bool i32` source
constructors, source `match` over `(result f64 i32)` or `(result bool i32)`,
shell parsing, option/flag parsing, subcommands, environment-backed
configuration, stable CLI framework APIs, stable ABI/layout/ownership,
optimizer guarantees, benchmark thresholds, or beta maturity.

## exp-53 (released experimental alpha)

Release label: `exp-53`

Release name: Standard CLI Source Facade Alpha

Release date: 2026-05-19

Status: released experimental alpha language/tooling contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_53_STANDARD_CLI_SOURCE_FACADE_ALPHA.md`.

exp-53 adds `std/cli.slo`, a narrow source-authored CLI facade that composes
`std.process` and `std.string` source modules. The matching fixture imports
`std.cli` explicitly without a local copied module.

The new fixture is `examples/projects/std-import-cli/`.

exp-53 does not add automatic standard-library imports, a `std.slo`
aggregator, package registry behavior, lockfiles, package std dependencies,
new compiler-known runtime names, shell parsing, option/flag parsing,
subcommands, environment-backed configuration, stable CLI framework APIs,
stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or
beta maturity.

## exp-52 (released experimental alpha)

Release label: `exp-52`

Release name: Standard Process Facade Source Search Alpha

Release date: 2026-05-19

Status: released experimental alpha language/tooling contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_52_STANDARD_PROCESS_FACADE_SOURCE_SEARCH_ALPHA.md`.

exp-52 adds `std/process.slo`, a narrow source-authored facade over already
promoted process argument runtime calls. The matching fixture imports
`std.process` explicitly without a local copied module.

The new fixture is `examples/projects/std-import-process/`.

exp-52 does not add automatic standard-library imports, a `std.slo`
aggregator, package registry behavior, lockfiles, package std dependencies,
new compiler-known process runtime names, process spawning, exit/status
control, current-directory APIs, signal handling, stable ABI/layout/ownership,
optimizer guarantees, benchmark thresholds, or beta maturity.

## exp-51 (released experimental alpha)

Release label: `exp-51`

Release name: Standard Library Path List Alpha

Release date: 2026-05-19

Status: released experimental alpha language/tooling contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_51_STANDARD_LIBRARY_PATH_LIST_ALPHA.md`.

exp-51 refines explicit standard-source discovery so `SLOVO_STD_PATH` may
name an ordered OS path list of standard-library roots. This allows an
override root to sit before an installed or checkout root without copying the
entire `std/` tree.

exp-51 does not add automatic standard-library imports, a `std.slo`
aggregator, package registry behavior, lockfiles, package std dependencies,
semantic version solving, stable package manager behavior, broad
standard-library APIs, stable ABI/layout/ownership, optimizer guarantees,
benchmark thresholds, or beta maturity.

## exp-50 (released experimental alpha)

Release label: `exp-50`

Release name: Installed Standard Library Discovery Alpha

Release date: 2026-05-19

Status: released experimental alpha language/tooling contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_50_INSTALLED_STANDARD_LIBRARY_DISCOVERY_ALPHA.md`.

exp-50 extends the explicit standard-source import contract to installed
toolchain discovery. Glagol may now discover staged `std/*.slo` files from an
installed `share/slovo/std` layout near the compiler executable, while keeping
`SLOVO_STD_PATH` and checkout discovery available.

exp-50 does not add automatic standard-library imports, a `std.slo`
aggregator, package registry behavior, lockfiles, package std dependencies,
new standard-library modules, stable install layout guarantees, stable
ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta
maturity.

## exp-49 (released experimental alpha)

Release label: `exp-49`

Release name: Standard IO Facade Source Search Alpha

Release date: 2026-05-19

Status: released experimental alpha language/tooling contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_49_STANDARD_IO_FACADE_SOURCE_SEARCH_ALPHA.md`.

exp-49 extends explicit project-mode standard-library source search to
`std.io`. `std/io.slo` now carries an export list, and the matching fixture
imports the module without a local copy.

The new fixture is `examples/projects/std-import-io/`.

exp-49 does not add automatic standard-library imports, a `std.slo`
aggregator, package registry behavior, installed toolchain stdlib paths, new
compiler-known IO names, formatted output APIs, stable ABI/layout/ownership,
optimizer guarantees, benchmark thresholds, or beta maturity.

## exp-48 (released experimental alpha)

Release label: `exp-48`

Release name: Standard Core Facade Source Search Alpha

Release date: 2026-05-19

Status: released experimental alpha language/tooling contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_48_STANDARD_CORE_FACADE_SOURCE_SEARCH_ALPHA.md`.

exp-48 extends explicit project-mode standard-library source search to the
pure source facade modules `std.string` and `std.num`. `std/string.slo` and
`std/num.slo` now carry export lists, and the matching fixtures import those
modules without local copies.

The new fixtures are `examples/projects/std-import-string/` and
`examples/projects/std-import-num/`.

exp-48 does not add automatic standard-library imports, a `std.slo`
aggregator, package registry behavior, installed toolchain stdlib paths,
generic parse/format APIs, broad numeric casts, stable ABI/layout/ownership,
optimizer guarantees, benchmark thresholds, or beta maturity.

## exp-47 (released experimental alpha)

Release label: `exp-47`

Release name: Standard Host Facade Source Search Alpha

Release date: 2026-05-19

Status: released experimental alpha language/tooling contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_47_STANDARD_HOST_FACADE_SOURCE_SEARCH_ALPHA.md`.

exp-47 extends explicit project-mode standard-library source search to the
host facade modules `std.time`, `std.random`, `std.env`, and `std.fs`.
`std/time.slo`, `std/random.slo`, `std/env.slo`, and `std/fs.slo` now carry
export lists, and the matching fixtures import those modules without local
copies.

The new fixtures are `examples/projects/std-import-time/`,
`examples/projects/std-import-random/`, `examples/projects/std-import-env/`,
and `examples/projects/std-import-fs/`.

exp-47 does not add automatic standard-library imports, a `std.slo`
aggregator, workspace dependency syntax for std, package registry behavior,
installed toolchain stdlib paths, broad host APIs, stable ABI/layout/ownership,
optimizer guarantees, benchmark thresholds, or beta maturity.

## exp-46 (released experimental alpha)

Release label: `exp-46`

Release name: Workspace Standard Source Search Alpha

Release date: 2026-05-19

Status: released experimental alpha language/tooling contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_46_WORKSPACE_STANDARD_SOURCE_SEARCH_ALPHA.md`.

exp-46 extends explicit standard-library source search from single projects to
workspace packages. The new fixture `examples/workspaces/std-import-option/`
imports `(import std.option (...))` without a local copied `option.slo`.

exp-46 does not add automatic standard-library imports, workspace dependency
syntax for std, package registry behavior, installed toolchain stdlib paths,
a `std.slo` aggregator, generic option helpers, broad standard-library APIs,
stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or
beta maturity.

## exp-45 (released experimental alpha)

Release label: `exp-45`

Release name: Standard Result And Option Source Search Alpha

Release date: 2026-05-19

Status: released experimental alpha language/tooling contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_45_STANDARD_RESULT_OPTION_SOURCE_SEARCH_ALPHA.md`.

exp-45 extends the explicit standard-library source-search path to
`std.result` and `std.option`. Ordinary project code may import
`(import std.result (...))` and `(import std.option (...))`, and Glagol
resolves those imports to repo-root `std/result.slo` and `std/option.slo`
without local module copies.

`std/result.slo` and `std/option.slo` now carry their own export lists. The
matching contract fixtures are `examples/projects/std-import-result/` and
`examples/projects/std-import-option/`.

exp-45 does not add automatic standard-library imports, a `std.slo`
aggregator, package registry behavior, workspace/package `std` imports,
generic result helpers, generic option helpers, broad standard-library APIs,
stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or
beta maturity.

## exp-44 (released experimental alpha)

Release label: `exp-44`

Release name: Standard Library Source Search Alpha

Release date: 2026-05-19

Status: released experimental alpha language/tooling contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_44_STANDARD_LIBRARY_SOURCE_SEARCH_ALPHA.md`.

exp-44 promotes the first explicit standard-library source search path:
ordinary project code may import the staged math helpers with
`(import std.math (...))` and Glagol resolves that import to repo-root
`std/math.slo` without copying `math.slo` into the project.

`std/math.slo` now carries its own export list so it can be imported as real
source. The matching contract fixture is
`examples/projects/std-import-math/`.

exp-44 does not add automatic standard-library imports, a `std.slo`
aggregator, package registry behavior, workspace/package `std` imports,
broad standard-library APIs, stable ABI/layout/ownership, optimizer
guarantees, benchmark thresholds, or beta maturity.

## exp-43 (released experimental alpha)

Release label: `exp-43`

Release name: Technical Whitepapers And Skills Alpha

Release date: 2026-05-19

Status: released experimental alpha documentation/tooling contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_43_TECHNICAL_WHITEPAPERS_AND_SKILLS_ALPHA.md`.

exp-43 publishes `docs/SLOVO_WHITEPAPER.md`, generated PDF publication
artifacts, and a repository-local beta language-design skill under
`.llm/skills/`.

exp-43 does not add source syntax, type forms, standard-library APIs, stable
ABI/layout/ownership, optimizer guarantees, benchmark thresholds,
cross-machine performance claims, package registry behavior, or beta maturity.

## exp-42 (released experimental alpha)

Release label: `exp-42`

Release name: Hot Loop Benchmark Mode Alpha

Release date: 2026-05-19

Status: released experimental alpha tooling contract. This is experimental
maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_42_HOT_LOOP_BENCHMARK_MODE_ALPHA.md`.

exp-42 keeps the Slovo language surface unchanged and pairs with Glagol
benchmark-suite gates that separate `cold-process` timing from
startup-amortized `hot-loop` timing.

exp-42 does not add source syntax, type forms, standard-library APIs, stable
ABI/layout/ownership, high-resolution timing APIs, optimizer guarantees,
benchmark thresholds, cross-machine performance claims, package registry
behavior, or beta maturity.

## exp-41 (released experimental alpha)

Release label: `exp-41`

Release name: Lisp Benchmark Comparison Alpha

Release date: 2026-05-19

Status: released experimental alpha tooling contract. This is experimental
maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_41_LISP_BENCHMARK_COMPARISON_ALPHA.md`.

exp-41 keeps the Slovo language surface unchanged and pairs with Glagol
benchmark-suite gates that compare two Lisp-family implementations:
Clojure and Common Lisp/SBCL.

exp-41 does not add source syntax, type forms, standard-library APIs, stable
ABI/layout/ownership, optimizer guarantees, benchmark thresholds,
cross-machine performance claims, package registry behavior, or beta maturity.

## exp-40 (released experimental alpha)

Release label: `exp-40`

Release name: Benchmark Suite And License Alpha

Release date: 2026-05-19

Status: released experimental alpha governance/tooling contract. This is
experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_40_BENCHMARK_SUITE_AND_LICENSE_ALPHA.md`.

exp-40 adds project licensing as `MIT OR Apache-2.0`, records alpha/beta
release naming criteria, and pairs with Glagol benchmark-suite gates for
Slovo/C/Rust/Python/Clojure local timing comparisons.

exp-40 does not add source syntax, type forms, standard-library APIs, stable
ABI/layout/ownership, optimizer guarantees, benchmark thresholds,
cross-machine performance claims, package registry behavior, or beta maturity.

## exp-39 (released experimental alpha)

Release label: `exp-39`

Release name: Standard Math Extensions And Benchmark Scaffold Alpha

Release date: 2026-05-19

Status: released experimental alpha Slovo contract. Matching Glagol source
checking, formatter, benchmark scaffold, gates, and review workflow are
required before broader compiler-support claims. This is experimental maturity
and not a beta maturity claim.

The normative release contract is
`.llm/EXP_39_STANDARD_MATH_EXTENSIONS_AND_BENCHMARK_SCAFFOLD_ALPHA.md`.

exp-39 extends staged `std/math.slo` with source-authored helpers for `i32`,
`i64`, and finite `f64`: `neg_*`, `cube_*`, `is_zero_*`, `is_positive_*`,
`is_negative_*`, and inclusive `in_range_*`. The existing exp-32 `abs`,
`min`, `max`, `clamp`, and `square` helpers remain.

The matching Glagol release adds a local `math-loop` benchmark scaffold for
comparing Slovo executable timing against C, Rust, and Python on the same
machine. Those timings are local tooling evidence only, not performance
thresholds or optimizer guarantees.

exp-39 does not add automatic `std` imports, repo-root `std/` search,
compiler-loaded standard-library 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 standard-library APIs, stable ABI/layout/ownership,
manifest schema changes, or beta maturity.

## exp-38 (released experimental alpha)

Release label: `exp-38`

Release name: Standard Host Source Facades Alpha

Release date: 2026-05-19

Status: released experimental alpha Slovo contract. Matching Glagol source
checking, formatter, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is
`.llm/EXP_38_STANDARD_HOST_SOURCE_FACADES_ALPHA.md`.

exp-38 adds staged source facades over already released host/runtime calls:

- `std/random.slo` with `random_i32 : () -> i32` and
  `random_i32_non_negative : () -> bool`
- `std/env.slo` with `get : (string) -> string` and
  `get_result : (string) -> (result string i32)`
- `std/fs.slo` with `read_text`, `read_text_result`, `write_text_status`, and
  `write_text_result`

The standard-library organization policy remains the exp-30 staged layout:
flat `std/*.slo` facades now, with a future `std.slo` aggregator/reexport layer
only after import/search semantics exist. This follows the Zig-like flat
standard facade policy adapted to current Slovo.

exp-38 does not add automatic `std` imports, repo-root `std/` search,
compiler-loaded standard-library source, new compiler-known `std.*` operation
names, standard-runtime catalog entries, seed/range/bytes/floats/UUID/crypto
random APIs, environment mutation/enumeration, rich host error ADTs,
binary/directory/streaming/async filesystem APIs, stable standard-library APIs,
stable ABI/layout/ownership, manifest schema changes, or beta maturity.

## exp-37 (released experimental alpha)

Release label: `exp-37`

Release name: Standard Time Source Facade Alpha

Release date: 2026-05-19

Status: released experimental alpha Slovo contract. Matching Glagol source
checking, formatter, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is
`.llm/EXP_37_STANDARD_TIME_SOURCE_FACADE_ALPHA.md`.

exp-37 adds the staged `std/time.slo` source facade with narrow wrappers over
the already released exp-8 host time calls:

- `monotonic_ms : () -> i32`
- `sleep_ms_zero : () -> i32`

`monotonic_ms` returns `std.time.monotonic_ms`. `sleep_ms_zero` calls
`std.time.sleep_ms 0` and then returns `0`, because user-defined unit-return
functions are not generally supported today and positive-duration timing
assertions remain deferred. exp-37 adds no compiler-known runtime names and no
entries to `STANDARD_RUNTIME.md`.

The standard-library organization policy remains the exp-30 staged layout:
flat `std/*.slo` facades now, with a future `std.slo` aggregator/reexport layer
only after import/search semantics exist. This follows the Zig-like flat
standard facade policy adapted to current Slovo.

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

## exp-36 (released experimental alpha)

Release label: `exp-36`

Release name: Standard Option Source Helpers Alpha

Release date: 2026-05-19

Status: released experimental alpha Slovo contract. Matching Glagol source
checking, formatter, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is
`.llm/EXP_36_STANDARD_OPTION_SOURCE_HELPERS_ALPHA.md`.

exp-36 adds the staged `std/option.slo` source facade with concrete helpers for
the already supported `(option i32)` family:

- `is_some_i32`
- `is_none_i32`
- `unwrap_some_i32`
- `unwrap_or_i32`

These are ordinary Slovo source functions over existing `is_some`, `is_none`,
`unwrap_some`, and `if` behavior. `unwrap_or_i32` returns the `some` payload
when present and otherwise returns the supplied fallback. exp-36 adds no
compiler-known runtime names and no entries to `STANDARD_RUNTIME.md`.

The standard-library organization policy remains the exp-30 staged layout:
flat `std/*.slo` facades now, with a future `std.slo` aggregator/reexport layer
only after import/search semantics exist. This is inspired by Zig's
facade/reexport approach but adapted to current Slovo.

exp-36 does not add automatic `std` imports, repo-root `std/` search,
compiler-loaded standard-library source, generic option helpers, option
payloads beyond `i32`, new compiler-known `std.*` operation names, stable
standard-library APIs, stable ABI/layout/ownership, manifest schema changes,
or beta maturity. exp-45 later promotes only explicit `std.option` source
search for this helper module.

## exp-35 (released experimental alpha)

Release label: `exp-35`

Release name: Standard Result Bool Source Helpers Alpha

Release date: 2026-05-19

Status: released experimental alpha Slovo contract. Matching Glagol source
checking, formatter, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is
`.llm/EXP_35_STANDARD_RESULT_BOOL_SOURCE_HELPERS_ALPHA.md`.

exp-35 extends the staged `std/result.slo` source file with concrete bool
helpers for the exp-34 returned `(result bool i32)` family:

- `is_ok_bool`
- `is_err_bool`
- `unwrap_ok_bool`
- `unwrap_err_bool`
- `unwrap_or_bool`

These are ordinary Slovo source functions over existing compiler-known
`std.result.is_ok`, `std.result.is_err`, `std.result.unwrap_ok`, and
`std.result.unwrap_err` support for the exp-34 bool parse result flow.
`unwrap_or_bool` returns the ok payload when present and otherwise returns the
supplied fallback. exp-35 adds no compiler-known runtime names and no entries
to `STANDARD_RUNTIME.md`.

At exp-35, Slovo still did not promote automatic `std` imports, a repo-root
`std/` search path, compiler-loaded standard library source, source-authored
generic result helpers, source constructors for `(result bool i32)`, or
general source `match` over `(result bool i32)` beyond the
compiler-supported fixture flow. exp-45 later promotes only explicit
`std.result` source search for this helper module.

exp-35 does not add supported/formatter example fixtures. It does not add
generic `std.result.map`, generic `std.result.unwrap_or`,
`std.result.and_then`, option helper names, broad result payload families,
automatic standard-library imports, replacement of compiler-known `std.*`
calls, new compiler-known `std.*` operation names, stable standard-library
APIs, stable ABI/layout/ownership, manifest schema changes, or beta maturity.

## exp-34 (released experimental alpha)

Release label: `exp-34`

Release name: String Parse Bool Result Alpha

Release date: 2026-05-19

Status: released experimental alpha Slovo contract. Matching Glagol
implementation, tests, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is
`.llm/EXP_34_STRING_PARSE_BOOL_RESULT_ALPHA.md`.

exp-34 promotes exactly one string parse standard-runtime call:

- `std.string.parse_bool_result : (string) -> (result bool i32)`

The call parses exactly complete ASCII lowercase `true` and `false`. Success
returns `ok true` or `ok false`; the empty string, uppercase or mixed-case
text, leading or trailing whitespace, numeric text, and any other text return
`err 1`. It does not trap for ordinary parse failure.

The release adds byte-identical fixtures
`examples/supported/string-parse-bool-result.slo` and
`examples/formatter/string-parse-bool-result.slo`.

exp-34 does not add generic parse APIs, trap-based parse, bool parsing beyond
exact lowercase `true`/`false`, string/bytes parse, whitespace trimming,
case-insensitive parsing, locale or Unicode boolean parsing, numeric boolean
parsing, rich parse errors, source-authored `std/result.slo` bool wrappers,
automatic `std` imports, compiler-loaded `std` source, stable helper
ABI/layout/ownership, manifest schema changes, or beta maturity.

## exp-33 (released experimental alpha)

Release label: `exp-33`

Release name: Standard Result Source Helpers Alpha

Release date: 2026-05-19

Status: released experimental alpha Slovo contract. Matching Glagol source
checking, formatter, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is
`.llm/EXP_33_STANDARD_RESULT_SOURCE_HELPERS_ALPHA.md`.

exp-33 extends the staged `std/result.slo` source file with source helpers for
already promoted concrete result families. It fills out missing
`is_err_i64`, `unwrap_err_i64`, `is_err_string`, `unwrap_err_string`,
`is_err_f64`, and `unwrap_err_f64` wrappers alongside the existing i32
helpers, and adds concrete `unwrap_or_i32`, `unwrap_or_i64`,
`unwrap_or_string`, and `unwrap_or_f64` helpers.

The numeric `unwrap_or_*` helpers are ordinary Slovo source functions
implemented with `std.result.is_ok`, `std.result.unwrap_ok`, `if`,
parameters, and explicit signatures. `unwrap_or_string` uses the existing
`(result string i32)` `match` shape to return the payload or fallback.
exp-33 adds no compiler-known runtime names and no entries to
`STANDARD_RUNTIME.md`.

At exp-33, Slovo still did not promote automatic `std` imports, a repo-root
`std/` search path, or compiler-loaded standard library source. exp-45 later
promotes explicit `std.result` source search while keeping automatic imports
deferred.

exp-33 does not add supported/formatter example fixtures. It does not add
generic `std.result.map`, generic `std.result.unwrap_or`,
`std.result.and_then`, option helper names, result payload families beyond the
already promoted concrete ones, automatic standard-library imports, replacement
of compiler-known `std.*` calls, new compiler-known `std.*` operation names,
stable standard-library APIs, stable ABI/layout/ownership, manifest schema
changes, or beta maturity.

## exp-32 (released experimental alpha)

Release label: `exp-32`

Release name: Standard Math Source Helpers Alpha

Release date: 2026-05-19

Status: released experimental alpha Slovo contract. Matching Glagol source
checking, formatter, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is
`.llm/EXP_32_STANDARD_MATH_SOURCE_HELPERS_ALPHA.md`.

exp-32 extends the staged `std/math.slo` source file with source-authored
helpers expressible in current Slovo:

- `abs_i64`, `min_i64`, `max_i64`, `clamp_i64`, and `square_i64`
- `abs_f64`, `min_f64`, `max_f64`, and `clamp_f64`

The existing exp-30 `i32` helpers and `square_f64` remain in place. The
helpers use existing same-type arithmetic/comparison, `if`, literals, calls,
and explicit signatures. They add no compiler-known runtime names and no
entries to `STANDARD_RUNTIME.md`.

At exp-32, Slovo did not yet promote automatic `std` imports, a repo-root
`std/` search path, or compiler-loaded standard library source. exp-44 later
promotes the first explicit `std.math` source-search path while keeping
automatic imports deferred.

exp-32 does not add supported/formatter example fixtures. It does not add
automatic standard-library imports, replacement of compiler-known `std.*`
calls, new compiler-known `std.*` operation names, a broad math library,
trigonometry, `sqrt`, `pow`, `f32`, unsigned or narrower integers, generics,
traits, overloads, mixed numeric arithmetic, numeric containers, stable
standard-library APIs, stable ABI/layout/ownership, manifest schema changes,
or beta maturity.

## exp-31 (released experimental alpha)

Release label: `exp-31`

Release name: Checked F64 To I64 Result Alpha

Release date: 2026-05-19

Status: released experimental alpha Slovo contract. Matching Glagol
implementation, tests, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is
`.llm/EXP_31_CHECKED_F64_TO_I64_RESULT_ALPHA.md`.

exp-31 promotes exactly one checked `f64` to `i64` result standard-runtime
call:

- `std.num.f64_to_i64_result : (f64) -> (result i64 i32)`

The call returns `ok value` only when the input is finite, exactly integral,
and within the signed `i64` range `-9223372036854775808` through
`9223372036854775807`. It returns `err 1` for non-finite, fractional, or
out-of-range input, without trapping for ordinary conversion failure.

The release adds byte-identical fixtures
`examples/supported/f64-to-i64-result.slo` and
`examples/formatter/f64-to-i64-result.slo`, plus a `std/num.slo` wrapper over
the promoted compiler-known call. The out-of-range fixture value is the
formatter-stable conservative `9223372036854776000.0`; the accepted exact
`9223372036854775808.0` spelling formats to that value. Detailed edge behavior
near the `f64`/`i64` limits remains implementation-owned Glagol test coverage.

exp-31 does not add unchecked casts, unchecked `f64` to `i64`, cast syntax,
generic `cast_checked`, `f32`, unsigned or narrower integer families,
additional numeric conversion families, mixed numeric arithmetic, broad math,
numeric containers, stable helper ABI/layout/ownership, manifest schema
changes, or beta maturity.

## exp-30 (released experimental alpha)

Release label: `exp-30`

Release name: Standard Library Source Layout Alpha

Release date: 2026-05-19

Status: released experimental alpha Slovo contract. Matching Glagol
implementation, tests, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is
`.llm/EXP_30_STANDARD_LIBRARY_SOURCE_LAYOUT_ALPHA.md`.

exp-30 establishes `std/` as the Slovo source home for staged standard library
modules and examples. It adds `std/README.md`, `std/io.slo`,
`std/string.slo`, `std/num.slo`, `std/result.slo`, and `std/math.slo`.

`std/math.slo` contains narrow source-authored helpers expressible with the
current language: `abs_i32`, `min_i32`, `max_i32`, `clamp_i32`,
`square_i32`, and `square_f64`. The other `std/*.slo` files provide small
source wrappers over already promoted compiler-known standard-runtime calls
where current Slovo can express the wrapper cleanly.

The release adds the conservative formatter example
`examples/formatter/std-source-layout-alpha.slo`. It demonstrates the helper
shape and layout contract without claiming repo-root `std` import/search
support.

exp-30 does not add automatic standard-library imports, replace
compiler-known `std.*` calls with source implementations, add compiler-known
`std.*` operation names, change `STANDARD_RUNTIME.md`, add generics, traits,
overloads, package registry behavior, manifest schema changes, stable
standard-library APIs, stable ABI/layout/ownership, broad math, trigonometry,
`pow`, `sqrt`, `f32`, unsigned or narrower integers, mixed numeric
arithmetic, numeric containers, or beta maturity.

## exp-29 (released experimental alpha)

Release label: `exp-29`

Release name: Numeric Struct Fields Alpha

Release date: 2026-05-19

Status: released experimental alpha Slovo contract. Matching Glagol
implementation, tests, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is
`.llm/EXP_29_NUMERIC_STRUCT_FIELDS_ALPHA.md`.

exp-29 promotes direct immutable struct field declarations whose field types
are exactly `i64` or `f64`, alongside already supported direct `i32`, `bool`,
immutable `string`, and current enum fields.

It supports struct constructors with `i64` and finite `f64` field
initializers, immutable value flow through locals, parameters, returns, and
calls, field access returning `i64` or `f64`, and use of accessed fields with
existing same-type arithmetic/comparison and existing numeric print/format
helpers where already supported.

The release adds byte-identical fixtures
`examples/supported/numeric-struct-fields.slo` and
`examples/formatter/numeric-struct-fields.slo`.

exp-29 keeps the exp-20 finite-only `f64` policy. It does not 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 changes, FFI layout claims, or beta maturity.

## exp-28 (released experimental alpha)

Release label: `exp-28`

Release name: String Parse F64 Result Alpha

Release date: 2026-05-19

Status: released experimental alpha Slovo contract. Matching Glagol
implementation, tests, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is
`.llm/EXP_28_STRING_PARSE_F64_RESULT_ALPHA.md`.

exp-28 promotes exactly one string parse standard-runtime call:

- `std.string.parse_f64_result : (string) -> (result f64 i32)`

The call parses complete finite ASCII decimal `f64` text. Success returns
`ok value`; ordinary parse failure, non-finite text, trailing or leading
unsupported characters, and out-of-domain input return `err 1`. It does not
trap for ordinary parse or domain failure.

The release adds byte-identical fixtures
`examples/supported/string-parse-f64-result.slo` and
`examples/formatter/string-parse-f64-result.slo`.

exp-28 does not 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 changes, or beta maturity.

## exp-27 (released experimental alpha)

Release label: `exp-27`

Release name: Checked F64 To I32 Result Alpha

Release date: 2026-05-19

Status: released experimental alpha Slovo contract. Matching Glagol
implementation, tests, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is
`.llm/EXP_27_F64_TO_I32_RESULT_ALPHA.md`.

exp-27 promotes exactly one checked `f64` to `i32` result standard-runtime
call:

- `std.num.f64_to_i32_result : (f64) -> (result i32 i32)`

The call returns `ok value` only when the input is finite, exactly integral,
and within the signed `i32` range `-2147483648` through `2147483647`. It
returns `err 1` for non-finite, fractional, or out-of-range input, without
trapping for ordinary conversion failure.

The release adds byte-identical fixtures
`examples/supported/f64-to-i32-result.slo` and
`examples/formatter/f64-to-i32-result.slo`.

exp-27 does not add unchecked `f64` to `i32`, casts or cast syntax, generic
`cast_checked`, `f32`, unsigned or narrower integer families, additional
numeric conversion families, `f64` parse, mixed numeric arithmetic, numeric
containers, stable helper ABI/layout/ownership, manifest schema changes, or
beta maturity.

## exp-26 (released experimental alpha)

Release label: `exp-26`

Release name: F64 To String Alpha

Release date: 2026-05-18

Status: released experimental alpha Slovo contract. Matching Glagol
implementation, tests, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is `.llm/EXP_26_F64_TO_STRING_ALPHA.md`.

exp-26 promotes exactly one finite `f64` formatting standard-runtime call:

- `std.num.f64_to_string : (f64) -> string`

The release adds byte-identical fixtures
`examples/supported/f64-to-string.slo` and
`examples/formatter/f64-to-string.slo`.

exp-26 does not add `f32`, `f64` parse, generic format/display/interpolation,
locale/base/radix/grouping/padding/precision controls, stable NaN/infinity
text, implicit conversion, stable helper ABI/layout/ownership, manifest schema
changes, or beta maturity.

## exp-25 (released experimental alpha)

Release label: `exp-25`

Release name: String Parse I64 Result Alpha

Release date: 2026-05-18

Status: released experimental alpha Slovo contract. Matching Glagol
implementation, tests, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is
`.llm/EXP_25_STRING_PARSE_I64_RESULT_ALPHA.md`.

exp-25 promotes exactly one string parse standard-runtime call:

- `std.string.parse_i64_result : (string) -> (result i64 i32)`

The call parses an entire non-empty ASCII signed decimal `i64` string with an
optional leading `-`. Success returns `ok value`; parse failure or
out-of-range input returns `err 1`. It does not trap for ordinary parse or
range failure.

The release also adds byte-identical fixtures
`examples/supported/string-parse-i64-result.slo` and
`examples/formatter/string-parse-i64-result.slo`.

exp-25 does not add `f64` parse, generic parse APIs, a leading `+`,
whitespace trimming, underscores, base/radix prefixes, locale-aware parsing,
Unicode digit parsing, rich parse errors, stable helper ABI/layout/ownership,
manifest schema changes, or beta maturity.

## exp-24 (released experimental alpha)

Release label: `exp-24`

Release name: Integer To String Alpha

Release date: 2026-05-18

Status: released experimental alpha Slovo contract. Matching Glagol
implementation, tests, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is
`.llm/EXP_24_INTEGER_TO_STRING_ALPHA.md`.

exp-24 promotes exactly two integer formatting standard-runtime calls:

- `std.num.i32_to_string : (i32) -> string`
- `std.num.i64_to_string : (i64) -> string`

Each call returns a decimal signed ASCII string for the input value. Negative
values include a leading `-`; non-negative values have no leading `+`. The
operations are compiler/runtime-backed for now and may later be rewritten in
Slovo `std` source once the language can host them.

The release also adds byte-identical fixtures
`examples/supported/integer-to-string.slo` and
`examples/formatter/integer-to-string.slo`.

exp-24 does not add `f64` formatting, parse APIs, locale/base/radix/grouping
or padding controls, generic format/display traits, implicit conversions,
stable standard-library implementation source, stable helper ABI/layout and
ownership, manifest schema changes, or beta maturity.

## exp-23 (released experimental alpha)

Release label: `exp-23`

Release name: Checked I64-To-I32 Conversion Alpha

Release date: 2026-05-18

Status: released experimental alpha Slovo contract. Matching Glagol
implementation, tests, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is
`.llm/EXP_23_CHECKED_I64_TO_I32_CONVERSION_ALPHA.md`.

exp-23 promotes exactly one checked narrowing standard-runtime call:

- `std.num.i64_to_i32_result : (i64) -> (result i32 i32)`

The call returns `ok value` when the signed `i64` input is within the signed
`i32` range `-2147483648` through `2147483647`, and returns `err 1` when the
input is outside that range. It does not trap on range failure.

The release also adds byte-identical fixtures
`examples/supported/checked-i64-to-i32-conversion.slo` and
`examples/formatter/checked-i64-to-i32-conversion.slo`.

The operation is an explicit call returning the existing concrete
`(result i32 i32)` family. exp-23 does not add implicit numeric promotion,
cast syntax, `std.num.cast`, checked cast generics, mixed numeric operators,
any other narrowing conversion, `f64` conversions, unsigned or narrower
integer families, numeric parse/format APIs, standard-library implementation
promises, stable ABI/layout, manifest schema changes, or beta maturity.

## exp-22 (released experimental alpha)

Release label: `exp-22`

Release name: Numeric Widening Conversions Alpha

Release date: 2026-05-18

Status: released experimental alpha Slovo contract. Matching Glagol
implementation, tests, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is
`.llm/EXP_22_NUMERIC_WIDENING_CONVERSIONS_ALPHA.md`.

exp-22 promotes exactly three explicit standard-runtime numeric widening
calls:

- `std.num.i32_to_i64 : (i32) -> i64`
- `std.num.i32_to_f64 : (i32) -> f64`
- `std.num.i64_to_f64 : (i64) -> f64`

The release also adds byte-identical fixtures
`examples/supported/numeric-widening-conversions.slo` and
`examples/formatter/numeric-widening-conversions.slo`.

These operations are explicit calls. exp-22 does not add implicit numeric
promotion, mixed `i32`/`i64`/`f64` arithmetic or comparison, narrowing
conversions, checked numeric conversion result APIs, numeric cast syntax,
`f32`, unsigned or narrower integer families, numeric parse/format APIs,
stable floating rounding or formatting guarantees, stable ABI/layout, manifest
schema changes, or beta maturity.

## exp-21 (released experimental contract)

Release label: `exp-21`

Release name: I64 Numeric Primitive Alpha

Release date: 2026-05-18

Status: released experimental Slovo contract. Matching Glagol implementation,
tests, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is
`.llm/EXP_21_I64_NUMERIC_PRIMITIVE_ALPHA.md`.

exp-21 allows direct `i64` value flow, explicit signed decimal `i64` literal
atoms, same-type arithmetic/comparison, and one print operation:

```slo
(fn adjust ((value i64) (delta i64)) -> i64
  (+ value delta))
```

It promotes:

- direct `i64` function parameters and returns
- immutable `let` locals declared as `i64`
- explicit signed decimal `i64` literal atoms such as `2147483648i64`,
  `42i64`, and `-7i64`
- calls passing and returning `i64`
- same-type `i64` `+`, `-`, `*`, and `/`
- same-type `i64` `=`, `<`, `>`, `<=`, and `>=`
- `std.io.print_i64`
- byte-identical fixtures
  `examples/supported/i64-numeric-primitive.slo` and
  `examples/formatter/i64-numeric-primitive.slo`

Unsuffixed integer literals remain the existing `i32` surface, and `main`
continues to return `i32`.

exp-21 does not add `f32`, unsigned integers, narrower integer widths beyond
existing `i32`, `char`, `bytes`, `decimal`, numeric casts, implicit promotion,
mixed `i32`/`i64`/`f64` arithmetic, generic numeric operators, i64
arrays/vectors/options/results/enum payloads/struct fields, mutable `i64`
locals, `parse_i64`, random `i64`, broader math APIs, stable divide-by-zero or
overflow diagnostics, stable ABI/layout, manifest schema changes, or beta
maturity.

## exp-20 (released experimental contract)

Release label: `exp-20`

Release name: F64 Numeric Primitive Alpha

Release date: 2026-05-18

Status: released experimental Slovo contract. Matching Glagol implementation,
tests, gates, and review workflow are required before broader
compiler-support claims. This is experimental maturity and not a beta maturity
claim.

The normative release contract is
`.llm/EXP_20_F64_NUMERIC_PRIMITIVE_ALPHA.md`.

exp-20 allows direct `f64` value flow, same-type arithmetic/comparison, and
one print operation:

```slo
(fn half ((value f64)) -> f64
  (/ value 2.0))
```

It promotes:

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

exp-20 does not add `f32`, `i64/u64/u32/u16/u8/i16/i8`, `char`, `bytes`,
`decimal`, numeric casts, implicit promotion, mixed `i32`/`f64` arithmetic,
generic numeric operators, f64 arrays/vectors/options/results/enum payloads/
struct fields, mutable `f64` locals, `parse_f64`, random floats, broader math
library calls, stable NaN/infinity/rounding semantics, stable print text
formatting beyond newline-terminated output, stable ABI/layout, manifest
schema changes, or beta maturity.

## exp-19 (released experimental contract)

Release label: `exp-19`

Release name: Primitive Struct Fields Alpha

Release date: 2026-05-18

Status: released experimental Slovo contract. Matching Glagol implementation,
tests, gates, and review workflow are required before broader compiler-support
claims. This is experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_19_PRIMITIVE_STRUCT_FIELDS_ALPHA.md`.

exp-19 allows direct `bool` and immutable `string` field types alongside
already supported direct `i32` fields and exp-18 direct enum fields:

```slo
(struct PrimitiveRecord
  (id i32)
  (active bool)
  (label string))
```

It promotes:

- struct field declarations using direct `bool` and immutable `string`
  field types
- struct construction with `i32`, `bool`, and immutable `string` field values
- field access returning the declared primitive field type
- bool field access in existing predicate positions
- string field access in existing string equality and `std.string.len`
- immutable local, parameter, return, call, test, and `main` flow for structs
  carrying primitive fields
- byte-identical fixtures
  `examples/supported/primitive-struct-fields.slo` and
  `examples/formatter/primitive-struct-fields.slo`

exp-19 does not add arrays, vectors, options, or results containing
primitive-field structs, primitive fields inside containers, nested structs,
struct mutation, string mutation, ownership/cleanup guarantees beyond existing
string behavior, broader string operations, printing beyond existing calls,
generics, methods, traits, manifest schema changes, package/import widening,
stable ABI/layout, or beta maturity.

## exp-18 (released experimental contract)

Release label: `exp-18`

Release name: Enum Struct Fields Alpha

Release date: 2026-05-18

Status: released experimental Slovo contract. Matching Glagol implementation,
tests, gates, and review workflow are required before broader compiler-support
claims. This is experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_18_ENUM_STRUCT_FIELDS_ALPHA.md`.

exp-18 allows current user-defined enum types as direct struct field types:

```slo
(enum Status Ready Blocked)

(enum Reading
  Missing
  (Value i32))

(struct TaggedReading
  (status Status)
  (reading Reading))
```

It promotes:

- struct field declarations using current enum type names directly
- struct construction with payloadless and unary `i32` enum field values
- field access returning the declared enum type
- same-enum equality on field access
- exhaustive enum `match` on field access
- immutable local, parameter, return, call, test, and `main` flow for structs
  carrying enum fields
- byte-identical fixtures
  `examples/supported/enum-struct-fields.slo` and
  `examples/formatter/enum-struct-fields.slo`

The enum surface is exactly exp-4 payloadless variants plus exp-16 unary
`i32` payload variants. exp-18 does not add payload types other than `i32`,
multiple payloads, record variants, tuple variants beyond one `i32`, arrays,
vectors, options, or results containing enum values, nested structs, struct
mutation, enum mutation, printing, ordering, hashing, reflection, stable
ABI/layout, manifest schema changes, import aliases/globs/re-exports,
registry/package-manager claims, generics, or beta maturity.

## exp-17 (released experimental contract)

Release label: `exp-17`

Release name: Project Enum Imports Alpha

Release date: 2026-05-18

Status: released experimental Slovo contract. Matching Glagol implementation,
tests, gates, and review workflow are required before broader compiler-support
claims. This is experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_17_PROJECT_ENUM_IMPORTS_ALPHA.md`.

exp-17 extends the existing explicit project/workspace module export and
import lists so top-level user-defined enum names can cross local module
boundaries:

```slo
(module readings (export Reading))

(import readings (Reading))
```

It promotes imported enum type use in:

- function signatures
- immutable locals
- calls and returns
- same-enum equality
- exhaustive enum matches
- qualified constructors

The enum surface is exactly exp-4 payloadless variants plus exp-16 unary
`i32` payload variants. Payloadless constructors remain zero-argument
qualified constructors, and unary payload constructors still take exactly one
`i32` argument.

The exp-17 project fixture is:

```text
examples/projects/enum-imports/slovo.toml
examples/projects/enum-imports/src/readings.slo
examples/projects/enum-imports/src/main.slo
```

exp-17 does not add payload types other than `i32`, multiple payloads, record
variants, tuple variants beyond one `i32`, generics, containers, mutation,
printing, ordering, hashing, reflection, unqualified variant constructors,
stable ABI/layout, manifest schema changes, registry/package-manager claims,
or beta maturity.

## exp-16 (released experimental contract)

Release label: `exp-16`

Release name: Unary I32 Enum Payloads Alpha

Release date: 2026-05-18

Status: released experimental Slovo contract. Matching Glagol implementation,
tests, gates, and review workflow are required before broader compiler-support
claims. This is experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_16_UNARY_I32_ENUM_PAYLOADS_ALPHA.md`.

exp-16 extends user-defined enums to allow payloadless variants plus unary
`i32` payload variants:

```slo
(enum Reading
  Missing
  (Value i32)
  (Offset i32))
```

It promotes:

- qualified unary payload constructors such as `(Reading.Value value)`
- payloadless constructors such as `(Reading.Missing)` unchanged
- enum `match` arms with payloadless patterns and one immutable arm-local
  payload binding for payload variants
- immutable local, parameter, return, call, test, and `main` flow for enum
  values
- same-enum equality where payload variants compare by tag and payload, and
  payloadless variants compare by tag
- byte-identical fixtures
  `examples/supported/enum-payload-i32.slo` and
  `examples/formatter/enum-payload-i32.slo`

exp-16 does not add payload types other than `i32`, multiple payloads, record
variants, tuple variants beyond one `i32`, string/bool/struct/enum payloads,
generic enums, generic functions, type aliases, traits, methods, derives,
wildcard/rest/nested enum patterns, pattern guards, enum payload mutation,
enum values inside arrays/structs/options/results/vectors, enum printing,
ordering, hashing, reflection, discriminants, stable ABI/layout, manifest
schema changes, runtime ABI/layout claims, moving option/result to ordinary
standard-library types, or beta maturity.

## exp-15 (released experimental contract)

Release label: `exp-15`

Release name: Result Helper Standard Names Alpha

Release date: 2026-05-18

Status: released experimental Slovo contract with matching Glagol
implementation, tests, gates, and review workflow. This is experimental
maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_15_RESULT_HELPER_STANDARD_NAMES_ALPHA.md`.

exp-15 is a narrow result helper standard-name alpha:

- promotes preferred source-level names `std.result.is_ok`,
  `std.result.is_err`, `std.result.unwrap_ok`, and `std.result.unwrap_err`
- accepts those names only for `(result i32 i32)` and `(result string i32)`
- keeps legacy unqualified `is_ok`, `is_err`, `unwrap_ok`, and `unwrap_err`
  documented as compatibility syntax where already supported
- reuses existing result observer and trap-based unwrap semantics
- adds byte-identical fixtures
  `examples/supported/result-helpers.slo` and
  `examples/formatter/result-helpers.slo`
- keeps `slovo.artifact-manifest` schema version `1`

exp-15 does not add `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, or beta maturity.

## exp-14 (released experimental contract)

Release label: `exp-14`

Release name: Standard Runtime Conformance Alignment

Release date: 2026-05-18

Status: released experimental conformance alignment after matching Glagol
exp-14 implementation, tests, focused conformance gate, full release gate, and
review passed. This is experimental maturity and not a beta maturity claim.

The normative release contract is
`.llm/EXP_14_STANDARD_RUNTIME_CONFORMANCE_ALIGNMENT.md`.

exp-14 is a conformance/readiness alignment seed over the released exp-13
surface:

- catalogs every promoted compiler-known `std.*` operation through exp-13 in
  `STANDARD_RUNTIME.md`
- keeps the supported fixture inventory explicit
- adds byte-identical canonical fixtures for the already released exp-8 time
  operations:
  `examples/supported/time-sleep.slo` and
  `examples/formatter/time-sleep.slo`
- requires Slovo/Glagol supported and formatter fixtures to stay byte-aligned
  where matching files exist
- requires a fresh-project workflow covering `new`, `check`, `fmt --check`,
  `test`, `doc`, and `build` where the hosted toolchain exists
- requires an integrated workflow over already released features: modules/
  imports, tests, strings, `std.string.concat`,
  `std.string.parse_i32_result`, result `match`, `(vec i32)`, enum `match`,
  and `std.io.print_i32`
- keeps the release gate strict: diff checks, `cargo fmt --check`,
  `cargo test`, ignored promotion gate, binary smoke, LLVM smoke, and review
  `PASS`

The exp-14 release gate passed with Slovo/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 new 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-13 (released experimental contract)

Release label: `exp-13`

Release date: 2026-05-18

Status: released experimental compiler support after matching Glagol exp-13
implementation, tests, review, and full release gate coverage passed. This is
not a beta maturity claim.

The normative release contract is
`.llm/EXP_13_STRING_PARSE_I32_RESULT_ALPHA.md`.

exp-13 is a narrow string parse i32 result alpha:

- `std.string.parse_i32_result: (string) -> (result i32 i32)`
- parses the entire input string as ASCII decimal signed `i32`
- accepts an optional leading `-` and at least one ASCII 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)`
- only ordinary parse error code `err 1` is promised
- the operation composes structurally with
  `std.io.read_stdin_result` by matching the stdin result and parsing only the
  `ok` string payload

Release fixtures:

```text
examples/supported/string-parse-i32-result.slo
examples/formatter/string-parse-i32-result.slo
```

exp-13 does not add trap-based `std.string.parse_i32`, parsing floats, bools,
strings, or bytes, whitespace/locale/base-prefix/underscore/plus-sign parsing,
generic parse APIs, parse error messages or richer codes, Unicode digit
parsing, string indexing or slicing, tokenizer/scanner APIs, stdin line APIs,
stable helper ABI/layout, manifest schema fields, or beta maturity.

## exp-12 (released experimental contract)

Release label: `exp-12`

Release date: 2026-05-18

Status: released experimental compiler support after matching Glagol exp-12
implementation, tests, review, and release gate coverage passed. This is not a
beta maturity claim.

The normative release contract is
`.llm/EXP_12_STDIN_RESULT_ALPHA.md`.

exp-12 is a narrow standard input result alpha:

- `std.io.read_stdin_result: () -> (result string i32)`
- reads remaining standard input as text
- success returns `(ok string i32 text)`
- ordinary EOF with no bytes is success with the empty string
- ordinary host/input failure returns `(err string i32 1)`
- only ordinary failure code `err 1` is promised
- Glagol test-runner behavior may use an implementation-owned fixed input
  string as `ok`
- existing exp-3 and exp-10 host calls stay unchanged

Release fixtures:

```text
examples/supported/stdin-result.slo
examples/formatter/stdin-result.slo
```

exp-12 does not add trap-based `std.io.read_stdin`, line iteration, prompt
APIs, terminal mode, binary stdin, streaming, async, encoding/Unicode promises
beyond existing string bytes, stable helper ABI/layout, manifest schema
changes, or beta maturity.

## exp-11 (released experimental contract)

Release label: `exp-11`

Release date: 2026-05-18

Status: released experimental compiler support after matching Glagol exp-11
implementation, tests, review, and release gate coverage passed. This is not a
beta maturity claim.

The normative release contract is
`.llm/EXP_11_BASIC_RANDOMNESS_ALPHA.md`.

exp-11 is a narrow basic randomness alpha:

- `std.random.i32: () -> i32`
- returns a non-negative implementation-owned pseudo-random or host-random
  `i32`
- suitable only for basic CLI use
- deterministic-enough Glagol test-runner behavior through an
  implementation-owned non-negative sample or sequence
- runtime/host inability to produce a value traps exactly as
  `slovo runtime error: random i32 unavailable`

Release fixtures:

```text
examples/supported/random.slo
examples/formatter/random.slo
```

exp-11 does not claim seed APIs, cryptographic/security suitability, bytes
APIs, ranges or bounds arguments, floats, random strings, UUIDs, broad
`std.random.*`, randomness-specific manifest fields, stable ABI/layout/helper
symbols, or beta maturity.

## exp-10 (released experimental contract)

Release label: `exp-10`

Release date: 2026-05-18

Status: released experimental compiler support after matching Glagol exp-10
implementation, tests, review, and release gate coverage passed. This is not a
beta maturity claim.

The normative release contract is
`.llm/EXP_10_RESULT_BASED_HOST_ERRORS_ALPHA.md`.

exp-10 is a narrow result-based host errors alpha:

- concrete `(result string i32)` only
- `std.process.arg_result: (i32) -> (result string i32)`
- `std.env.get_result: (string) -> (result string i32)`
- `std.fs.read_text_result: (string) -> (result string i32)`
- `std.fs.write_text_result: (string string) -> (result i32 i32)`
- ordinary host failure as `err 1`
- exp-3 calls unchanged

Release fixtures:

```text
examples/supported/host-io-result.slo
examples/formatter/host-io-result.slo
```

exp-10 does not claim general host error ADTs, `result string Error`,
platform-specific codes, error messages, result equality/printing/mapping,
broader host APIs, stable ABI/layout/helper symbols, manifest schema changes,
or beta maturity.

## exp-9 (released experimental contract)

Release label: `exp-9`

Release date: 2026-05-18

Status: released experimental compiler support after matching Glagol exp-9
implementation, tests, review, and release gate coverage passed. This is not a
beta maturity claim.

The normative release contract is
`.llm/EXP_9_RELIABILITY_PERFORMANCE_ECOSYSTEM_HARDENING.md`.

exp-9 is hardening-only over the released exp-8 baseline. It requires
reliability, performance, and ecosystem gates for the existing promoted
experimental surface: property/fuzz-style parser, formatter, diagnostic,
project graph, and runtime API tests where feasible; a source-reachable panic
audit; 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 adds no source language syntax, type-system behavior, standard-runtime
names, package features, manifest schema versions, stable ABI/layout promises,
public performance guarantees, or beta maturity.

## exp-8 (released experimental contract)

Release label: `exp-8`

Release date: 2026-05-18

Status: released experimental compiler support after matching Glagol exp-8
implementation, tests, review, and release gate coverage passed. This is not a
beta maturity claim.

## Summary

exp-8 narrows the broad concurrency and long-running programs roadmap category
to host time and sleep alpha for long-running command-line programs:

- compiler-known `std.time.monotonic_ms: () -> i32`
- compiler-known `std.time.sleep_ms: (i32) -> unit`
- host monotonic elapsed milliseconds with implementation-owned epoch
- valid `sleep_ms 0` behavior
- negative sleep durations rejected or trapped with
  `slovo runtime error: sleep_ms negative duration`
- deterministic test-runner handling for `sleep_ms 0`
- conservative structural or non-negative host-value test-runner support for
  `monotonic_ms`
- standard-runtime time usage recorded in artifact manifests only if existing
  manifest patterns already support standard-runtime usage metadata

The normative release contract is `.llm/EXP_8_HOST_TIME_SLEEP_ALPHA.md`.
exp-8 adds no source language syntax and does not claim threads, channels,
async, cancellation, actors, shared memory, data-race freedom, scheduling,
timers, wall-clock/calendar/timezone APIs, high-resolution timers, signal
handling, stable ABI/layout, or stable runtime helper symbols.

## exp-7 (released experimental contract)

Release label: `exp-7`

Release date: 2026-05-18

Status: released experimental compiler support after matching Glagol exp-7
implementation, tests, review, and release gate coverage. This is not a beta
maturity claim.

## Summary

exp-7 is deliberately limited to test selection and richer test-run metadata:

- `glagol test <file.slo|project> --filter <substring>`
- legacy `glagol --run-tests --filter <substring> <file.slo>` while Glagol
  keeps the legacy route
- deterministic substring selection against test display names
- selected tests execute in the existing deterministic order
- non-selected discovered tests are skipped and counted
- zero matches is a successful run with explicit discovered/selected/passed/
  failed/skipped counts
- additive text-output and artifact-manifest test-run metadata

The normative contract is `.llm/EXP_7_TEST_SELECTION_ALPHA.md`. exp-7 adds no
source language syntax and does not claim LSP, debug metadata, source maps,
SARIF, watch/daemon protocols, documentation comments, lint categories, or
benchmarks.

## exp-6 (released experimental contract)

Release label: `exp-6`

Release date: 2026-05-18

Status: released experimental compiler support after matching Glagol exp-6
implementation, tests, review, and release gate coverage. This is not a beta
maturity claim.

## Summary

exp-6 is deliberately limited to C FFI scalar imports:

- top-level imported C function declarations such as
  `(import_c c_add ((lhs i32) (rhs i32)) -> i32)`
- `i32`-only scalar parameters and `i32` or internal builtin `unit` returns
- a conservative C symbol name subset matching the Slovo import name
- lexical `(unsafe ...)` required at every imported C call site
- explicit local C source linking through `glagol build --link-c <path>`
- artifact-manifest recording of `foreign_imports` and `c_link_inputs`
- an interpreter-style test-runner diagnostic when a test reaches an imported
  C call

The normative contract is `.llm/EXP_6_C_FFI_SCALAR_IMPORTS_ALPHA.md`. The
minimal fixture target is `examples/ffi/exp-6-c-add/`.

## exp-6 Deferrals

exp-6 does not support pointer types, allocation/deallocation, raw unsafe head
execution, ownership or lifetime rules, C exports, callbacks, headers,
libraries, broad linker configuration, foreign globals, foreign structs,
unions, enums, layout annotations, stable ABI, or stable layout.

## exp-5 (released experimental contract)

Release label: `exp-5`

Release date: 2026-05-18

Status: released experimental compiler support after matching Glagol exp-5
implementation, tests, review, and release gate coverage. This is not a beta
maturity claim.

## Summary

exp-5 is deliberately limited to local packages and workspace hygiene:

- workspace `slovo.toml` manifests with explicit local member lists
- package `slovo.toml` manifests with package name/version metadata
- local path dependencies between workspace members
- deterministic package graph ordering
- explicit package-qualified imports for dependency modules
- package graph recording in artifact manifests
- diagnostics for missing package, dependency cycle, duplicate package name,
  path escape, invalid package name/version, and private visibility across
  package boundaries

The normative contract is `.llm/EXP_5_LOCAL_PACKAGES_ALPHA.md`. The minimal
fixture target is `examples/workspaces/exp-5-local/`.

## exp-5 Deferrals

exp-5 does not support remote registries, version solving, lockfiles beyond
deterministic local graph recording, build scripts, generated code, published
packages, semver compatibility promises, macros, package-level generics,
cross-package ABI stability, package re-exports, package archives, package
publishing, registry authentication, feature flags, optional dependencies, dev
dependencies, or target dependencies.

## exp-4 (released experimental contract)

Release label: `exp-4`

Release date: 2026-05-18

Status: released experimental compiler support after matching Glagol exp-4
implementation, tests, review, and release gate coverage. This is not a beta
maturity claim.

## Summary

exp-4 narrows user-defined data types to payloadless enums only:

```slo
(enum Name VariantA VariantB)
```

Variant values are constructed 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` requires exhaustive payloadless variant arms:

```slo
(match value
  ((Name.VariantA)
    body...)
  ((Name.VariantB)
    body...))
```

Arms have one or more expression bodies and a common final result type,
following the existing option/result match rule.

## Runtime And Layout

The runtime/backend representation is compiler-owned. exp-4 makes no stable
layout, discriminant value, ABI, helper-symbol, reflection, or conversion to
`i32` promise.

## Fixtures

exp-4 adds these current compiler-supported fixtures:

```text
examples/supported/enum-basic.slo
examples/formatter/enum-basic.slo
```

They are current exp-4 fixtures.

## exp-4 Deferrals

exp-4 does not support payload variants, tuple variants, record variants,
generic enums, generic functions, type aliases, traits, interfaces, protocols,
methods, derives, variant payload binding, wildcard patterns, rest patterns,
guards, nested patterns, enum values in arrays, enum values in struct fields,
enum values in options, enum values in results, enum values in vectors, enum
mutation, enum printing, enum ordering, enum hashing, reflection, explicit
discriminants, enum constructors with arguments, unqualified variant
constructors, stable ABI/layout, stable helper symbols, or moving
option/result to ordinary standard-library types.

## exp-3 (released experimental contract)

Release label: `exp-3`

Release date: 2026-05-17

Status: released experimental compiler support after matching Glagol exp-3
implementation, tests, review, and release gate coverage. This is not a beta
maturity claim.

## Summary

exp-3 narrows standard IO and host environment support to exactly six
compiler-known functions:

```text
std.io.eprint: (string) -> unit
std.process.argc: () -> i32
std.process.arg: (i32) -> string
std.env.get: (string) -> string
std.fs.read_text: (string) -> string
std.fs.write_text: (string string) -> i32
```

`std.io.eprint` writes to stderr without adding a newline. `std.process.argc`
returns the process argument count, and `std.process.arg` returns a zero-based
argument string. `std.env.get` returns the environment variable value, with a
missing variable returning the empty string in this stage.
`std.fs.read_text` reads a whole text file, and `std.fs.write_text` writes a
whole string to a path.

## Runtime Behavior

Out-of-range process argument access traps with:

```text
slovo runtime error: process argument index out of bounds
```

Host file read failure traps with:

```text
slovo runtime error: file read failed
```

Both messages are written to stderr with a trailing newline and exit with code
`1`.

`std.fs.write_text` returns `0` on success and `1` on host failure for this
stage.

## Fixture Targets

exp-3 adds these current compiler-supported fixture targets:

```text
examples/supported/host-io.slo
examples/formatter/host-io.slo
```

They are current exp-3 fixtures.

## exp-3 Deferrals

exp-3 does not support networking, async IO, binary file APIs, directory
traversal, terminal control, platform abstraction, general host error ADTs,
`result string Error`, package interaction, stdin full read or line iteration,
randomness, time, stable ABI/layout, or stable runtime helper symbols.

## exp-2 (released experimental contract)

Release label: `exp-2`

Release date: 2026-05-17

Status: released experimental compiler support after matching Glagol exp-2
implementation, tests, review, and release gate coverage. This is not a beta
maturity claim.

## Summary

exp-2 narrows collections to one concrete growable vector type:

```text
(vec i32)
```

The only promoted operations are compiler-known standard-runtime names:

```text
std.vec.i32.empty: () -> (vec i32)
std.vec.i32.append: ((vec i32), i32) -> (vec i32)
std.vec.i32.len: ((vec i32)) -> i32
std.vec.i32.index: ((vec i32), i32) -> i32
```

`std.vec.i32.append` returns a new immutable runtime-owned vector and does not
mutate its input. `(vec i32)` values may flow through immutable locals,
parameters, returns, calls, and top-level tests. Vector equality with `=`
compares lengths and `i32` elements in order.

## Runtime Behavior

Allocation failure traps with:

```text
slovo runtime error: vector allocation failed
```

Index failure traps with:

```text
slovo runtime error: vector index out of bounds
```

Both messages are written to stderr with a trailing newline and exit with code
`1`. Vector cleanup is compiler/runtime-owned and not source-visible.

## Fixture Targets

exp-2 adds these current compiler-supported fixture targets:

```text
examples/supported/vec-i32.slo
examples/formatter/vec-i32.slo
```

They are current exp-2 fixtures.

## exp-2 Deferrals

exp-2 does not support generic vectors, element types other than `i32`, vector
mutation, vector `var` or `set`, vector literals beyond empty/append
construction, a `push` alias, nested vectors, vectors in arrays, structs,
options, or results, iterators, slices, maps, sets, user-visible deallocation,
stable ABI/layout/helper symbols, packages, or IO expansion.

## exp-1 (released experimental contract)

Release label: `exp-1`

Release date: 2026-05-17

Status: current experimental compiler support after matching Glagol exp-1
implementation, tests, review, and release gate coverage.

## Summary

exp-1 is the first narrow step toward the future `1.0.0-beta` general-purpose
language threshold. It promotes one heap-created string operation:

```slo
(std.string.concat left right)
```

The exact signature is `(string, string) -> string`. The result is 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 runtime-owned strings as they do to literal-backed strings.

No legacy `string_concat` alias is introduced. `std.string.concat` is a
compiler-known standard-runtime name, not a user module, import, package
dependency, foreign function, or stable C ABI symbol.

## Runtime Behavior

Allocation failure traps with:

```text
slovo runtime error: string allocation failed
```

The message is written to stderr with a trailing newline and exits with code
`1`. Runtime-owned string cleanup is compiler/runtime-owned and not
source-visible.

## Fixture Targets

exp-1 adds these current compiler-supported fixture targets:

```text
examples/supported/owned-string-concat.slo
examples/formatter/owned-string-concat.slo
```

They are current exp-1 fixtures.

## exp-1 Deferrals

exp-1 does not support mutable strings, string containers, string indexing or
slicing, interpolation, formatting APIs, Unicode scalar/grapheme/display-width
APIs, user-visible allocation or deallocation, file IO, environment variables,
process arguments, time, randomness, packages, workspaces, generics,
overloading, user-defined standard modules, growable collections, raw-memory
execution, FFI, stable ABI, or stable layout.

## v2.0.0-beta.1

Release tag: `v2.0.0-beta.1`

Release date: 2026-05-17

## Summary

Slovo `v2.0.0-beta.1` is an experimental integration/readiness release based
on v1.7. It does not add new source language syntax or semantics unless that
behavior is already implemented and gate-proven in Glagol.

Experimental readiness means Slovo is usable for small real flat local
projects with:

- `glagol new`
- `glagol check`
- `glagol fmt --check`
- `glagol fmt --write`
- `glagol test`
- `glagol build`
- `glagol doc`
- artifact manifests
- JSON diagnostics
- the release-gate script

## Experimental-Supported Surface

The experimental language surface is the accumulated v1.1-v1.7 surface:
`i32`, `bool`, builtin internal `unit`, top-level tests, locals, `if`,
`while`, structs, fixed direct scalar arrays with checked indexing, string
value flow, option/result values and the exact v1.4 match slice,
standard-runtime alpha names, and the v1.6 lexical unsafe boundary with
reserved unsafe heads.

Basic IO is exactly `std.io.print_i32`, `std.io.print_string`,
`std.io.print_bool`, and `std.string.len`. There is no file IO, environment
variable IO, process argument IO, process control, or time/clock API in this
experimental release.

## Experimental Deferrals

Vectors and growable collections are deferred until future beta work unless
separately implemented and gate-proven in Glagol. Fixed direct scalar arrays
with checked indexing satisfy the experimental gate because this is an
integration/readiness release for small flat local projects; growable
collections require allocation, ownership/lifetime, mutation, capacity,
diagnostics, lowering, runtime tests, and documentation that remain future beta
work.

Slovo `v2.0.0-beta.1` also makes no stable ABI/layout, FFI, raw-memory
execution, LSP, debug metadata, source-map, file/env/process/time IO, or
package registry promise.

## v1.7

Release tag: `v1.7`

Release date: 2026-05-17

## Summary

Slovo v1.7 is a conservative developer experience hardening release over the
v1.6 language contract. It adds tooling contracts only and does not promote new
source language syntax, type-system behavior, runtime semantics, standard
runtime names, ABI/layout guarantees, LSP support, stable debug metadata, or
stable source maps.

v1.7 promotes contracts for:

- `glagol new <project-dir> [--name <name>]`
- `glagol fmt --check <file-or-project>`
- `glagol fmt --write <file-or-project>`
- `glagol doc <file-or-project> -o <dir>`
- a local release-gate script

## Project Scaffolding

`glagol new` creates a valid v1.3-style project containing `slovo.toml` and
`src/main.slo`. The generated main module must be small, testable, and limited
to already-supported language forms.

The command must fail without overwriting non-empty target directories.

## Formatter Modes

Plain `glagol fmt <file.slo>` remains stdout formatting and does not write the
input file.

`glagol fmt --check <file-or-project>` checks canonical formatting without
writing. `glagol fmt --write <file-or-project>` writes canonical formatting for
one file or for all immediate `.slo` project source modules in deterministic
module order.

## Documentation Generator

`glagol doc <file-or-project> -o <dir>` generates deterministic Markdown from
current source structure: modules, imports/exports, structs, functions, and
tests. It is a documentation generator, not a semantic reflection API.

## Release Gate

The repo must provide a script or documented command entry point that runs the
full v1 release gate locally without network, tag, push, or release-publication
side effects.

## v1.7 Deferrals

Slovo v1.7 does not support new language syntax or semantics, package
management, dependency management, stdin formatting, recursive directory
formatting, LSP, SARIF, watch mode, daemon protocols, debug adapters, stable
debug metadata, DWARF, stable standalone source-map files, semantic reflection,
runtime reflection, stable ABI, or stable layout.

## v1.6

Release tag: `v1.6`

Release date: 2026-05-17

## Summary

Slovo v1.6 is a conservative memory and unsafe design slice over the v1.5
contract. It does not promote raw memory, pointers, allocation, deallocation,
unchecked indexing, reinterpretation, or FFI execution.

Lexical `(unsafe ...)` remains the only unsafe boundary. v1.6 reserves these
compiler-known unsafe operation heads:

- `alloc`
- `dealloc`
- `load`
- `store`
- `ptr_add`
- `unchecked_index`
- `reinterpret`
- `ffi_call`

Safe code using one of these heads must receive `UnsafeRequired` before normal
call lookup. Code inside `(unsafe ...)` using one of these heads must receive
`UnsupportedUnsafeOperation` until a future release defines syntax, type
rules, lowering, runtime behavior, diagnostics, and tests.

User functions, imports, exports, and parameters cannot shadow the reserved
unsafe heads. Such declarations must be rejected with a structured
duplicate/reserved-name diagnostic.

## Memory Direction

v1.6 keeps safe values as the default Slovo memory model. Future memory work is
staged toward affine ownership plus explicit unsafe regions, but v1.6 does not
freeze ownership, pointer/reference types, allocator behavior, aliasing,
cleanup, or unsafe-region escape rules.

No stable ABI, layout, FFI, allocator, ownership, or raw-memory execution
promise is made in v1.6.

## Supported Fixture Changes

v1.6 adds no new supported source fixture because no raw unsafe operation is
promoted. The supported unsafe fixture remains:

```text
examples/supported/unsafe.slo
```

The speculative raw-memory example remains speculative:

```text
examples/speculative/unsafe-memory.slo
```

## v1.6 Deferrals

Slovo v1.6 does not support pointer types, raw allocation, raw deallocation,
pointer load/store, pointer arithmetic, unchecked indexing, raw
reinterpretation, FFI calls, foreign symbol execution, stable object/library or
header output, stable C ABI symbols, stable runtime layout, allocator APIs,
ownership transfer, or safe abstractions over unsafe operations.

## v1.5

Release tag: `v1.5`

Release date: 2026-05-17

## Summary

Slovo v1.5 is a conservative standard library alpha over the v1.4 contract. It
promotes stable source-level standard-runtime names for existing runtime
behavior without adding new data types, IO breadth, imports, packages,
allocation, Unicode length semantics, or ABI promises.

The matching Glagol v1.5 release implements this contract. v1.5 promotes:

- `std.io.print_i32`
- `std.io.print_string`
- `std.io.print_bool`
- `std.string.len`

These are compiler-known v1.5 standard-runtime names. They do not require
imports, do not name user modules, do not create package dependencies, and are
not stable C ABI symbols.

Legacy `print_i32`, `print_string`, `print_bool`, and `string_len` remain
compatibility aliases. New examples prefer the promoted `std.*` names.

## Standard Runtime Alpha

The promoted forms are:

```slo
(std.io.print_i32 value)
(std.io.print_string value)
(std.io.print_bool value)
(std.string.len value)
```

`std.io.print_i32` accepts exactly one `i32`, returns builtin `unit`, and keeps
the same stdout behavior as legacy `print_i32`.

`std.io.print_string` accepts exactly one `string`, returns builtin `unit`, and
keeps the same stdout behavior and source string-literal constraints as legacy
`print_string`.

`std.io.print_bool` accepts exactly one `bool`, returns builtin `unit`, and
keeps the same stdout behavior as legacy `print_bool`.

`std.string.len` accepts exactly one `string`, returns `i32`, and keeps the
same decoded-byte count semantics as legacy `string_len`.

## Diagnostics

Unknown or unpromoted `std.*` calls must produce structured diagnostics. The
suggested diagnostic code is `UnsupportedStandardLibraryCall`.

Arity and type mismatches for promoted `std.*` calls use the existing
arity/type diagnostics where applicable. Promoted `std.*` names are reserved
from user function/export shadowing.

## Supported Fixture Additions

v1.5 adds these Slovo fixtures:

```text
examples/supported/standard-runtime.slo
examples/formatter/standard-runtime.slo
```

## v1.5 Deferrals

Slovo v1.5 does not support `std.io.print_unit`, file IO, environment
variables, process arguments, time or clocks, vectors/maps/sets or other
collections, allocation, deallocation, ownership, user-defined standard
modules, imports or packages for standard-runtime names, overloading, generic
standard-library APIs, Unicode scalar/grapheme/display-width string length,
stable C ABI symbols, runtime layout promises, or FFI contracts.

## v1.4

Release tag: `v1.4`

Release date: 2026-05-17

## Summary

Slovo v1.4 is a conservative core-language expansion over the v1.3
project-mode contract. It promotes source-level `match` only for existing
`(option i32)` and `(result i32 i32)` values. It does not add user-defined
enums/ADTs, generic payloads, mutation, vectors, broader numeric types,
ownership, or layout/ABI promises.

Assuming the matching Glagol v1.4 release implements this contract, v1.4
promotes:

- `match` expressions over `(option i32)` and `(result i32 i32)`
- exhaustive option arms: `some` and `none`
- exhaustive result arms: `ok` and `err`
- immutable arm payload binding for `some`, `ok`, and `err`
- one-or-more expression arm bodies whose final expression is the arm value
- common arm result typing for the whole match expression
- named diagnostics for match subject, payload, exhaustiveness, duplicate arm,
  malformed pattern, arm type, binding collision, mutation, and container
  boundaries

Existing `is_some`, `is_none`, `is_ok`, `is_err`, `unwrap_some`, `unwrap_ok`,
and `unwrap_err` remain supported. New examples prefer `match` when control
flow depends on the payload.

## Match Syntax

Option matches use:

```slo
(match value
  ((some payload)
    payload)
  ((none)
    0))
```

Result matches use:

```slo
(match value
  ((ok payload)
    payload)
  ((err code)
    code))
```

Payload bindings are immutable and scoped only to the selected arm. Arm bodies
may contain one or more expressions. The final expression is the arm value, and
all arms must produce the same result type.

## Supported Fixture Additions

v1.4 adds these Slovo fixtures:

```text
examples/supported/option-result-match.slo
examples/formatter/option-result-match.slo
```

## v1.4 Deferrals

Slovo v1.4 does not support user-defined enums or algebraic data types,
generic option/result payloads, non-`i32` payload matching, nested
option/result payloads beyond current v1 limits, options/results in arrays or
structs, option/result mutation, vectors, struct mutation, `i64`, general
`(block ...)` expressions outside match arms, pattern guards, wildcard/rest
patterns, destructuring structs/arrays/strings, standard-library error
conventions, user-catchable exceptions, ownership promises, stable layout, or
stable ABI.

## v1.3

Release tag: `v1.3`

Release date: 2026-05-17

## Summary

Slovo v1.3 is a project-mode and local-modules release over the v1.2 language
and toolchain contract. It does not add packages, dependencies, remote
registries, version solving, workspaces, macros, public ABI, cross-package
visibility, incremental builds, watch/LSP, path escapes, or generated code.

Assuming the matching Glagol v1.3 release implements this contract, v1.3
promotes:

- a project manifest named `slovo.toml`
- a flat local source-root convention, defaulting to `src`
- project mode for `glagol check`, `glagol test`, and `glagol build`
- explicit imports between local project modules
- explicit exports of top-level `fn` and `struct` names
- deterministic project/module ordering
- duplicate-name, missing-import, import-cycle, ambiguous-name, and visibility
  diagnostics
- multi-file source spans and project artifact-manifest fields

Single-file mode remains unchanged when a command receives one `.slo` file.

## Project Manifest

The v1.3 manifest is exactly `slovo.toml`:

```toml
[project]
name = "example"
source_root = "src"
entry = "main"
```

`name` is required and must be a lowercase package-shaped identifier.
`source_root` defaults to `src` and must stay under the project root. `entry`
defaults to `main` and must be a flat module identifier. Unknown manifest
sections or keys are diagnostics in v1.3.

## Project Layout And Modules

Project module files are immediate `.slo` children of the source root:

```text
.
├── slovo.toml
└── src
    ├── main.slo
    └── math.slo
```

Each file declares one flat module whose name matches the file stem. A module
with exports uses:

```slo
(module math (export add_one))
```

The only import form is:

```slo
(import math (add_one))
```

Only exported top-level `fn` and `struct` declarations are importable. Tests,
locals, parameters, fields, builtins, intrinsics, generated declarations, and
imported names are not exportable or importable.

## Project Commands

Project mode is selected only when the input is a directory containing
`slovo.toml` or the `slovo.toml` file itself:

```text
glagol check <project-root>
glagol test <project-root>
glagol build <project-root> -o <binary>
```

`check` validates every project module. `test` checks the project and runs
top-level tests in deterministic module and source order. `build` checks the
project, requires the entry module and supported `main` function, and produces
one hosted native executable through the existing LLVM IR plus Glagol runtime C
plus Clang path.

## Supported Fixture Additions

v1.3 adds this Slovo project fixture:

```text
examples/projects/basic/slovo.toml
examples/projects/basic/src/main.slo
examples/projects/basic/src/math.slo
```

exp-17 later adds this project enum-import fixture:

```text
examples/projects/enum-imports/slovo.toml
examples/projects/enum-imports/src/readings.slo
examples/projects/enum-imports/src/main.slo
```

## v1.3 Deferrals

Slovo v1.3 does not support packages, dependencies, remote registries, version
solving, lockfiles, workspaces, hierarchical modules, import aliases, glob
imports, qualified names, re-exports, macros, public ABI, cross-package
visibility, incremental builds, watch mode, LSP, SARIF, path escapes,
generated code, project formatting, build profiles, cross-compilation, object
output, library output, header output, stable debug metadata, DWARF, or
standalone source maps.

## v1.2

Release tag: `v1.2`

Release date: 2026-05-17

## Summary

Slovo v1.2 is a practical runtime values release over the v1.1 single-file
toolchain contract. It does not add project mode, package management, imports,
multi-file modules, stable ABI/layout promises, or a standard runtime.

Assuming the matching Glagol v1.2 release implements this contract, v1.2
promotes:

- immutable string `let` locals
- string parameters and returns
- calls returning strings
- string equality with `=`
- string byte length with `string_len`
- top-level tests using string equality or string length comparisons
- temporary compiler/runtime intrinsic `print_bool`
- stable runtime trap messages and process exit behavior for array bounds and
  option/result unwrap failures

## Supported Fixture Additions

v1.2 adds these Slovo fixtures:

```text
examples/supported/string-value-flow.slo
examples/supported/print-bool.slo
examples/formatter/string-value-flow.slo
examples/formatter/print-bool.slo
```

No `print_unit` fixture is added because unit printing remains unsupported.

## Runtime String Contract

Strings remain immutable compiler/runtime values. Every promoted string value
originates from a source string literal or from propagating such a value through
an immutable local, parameter, return, or call result.

`string_len` returns the decoded byte count before the trailing NUL byte. String
equality compares decoded bytes before the trailing NUL byte. v1.2 does not
promise Unicode normalization, grapheme counting, display width, arbitrary byte
escapes, embedded NUL bytes, allocation, ownership, deallocation, stable ABI, or
FFI behavior.

String concatenation remains deferred in v1.2 because it requires allocation,
ownership, lifetime, and deallocation semantics. exp-1 later stages only the
narrow `std.string.concat` contract.

## Printing And Unit

`print_bool` has exactly one `bool` argument, returns builtin `unit`, and writes
`true\n` or `false\n`.

`print_unit` remains unsupported. This keeps `unit` as an internal builtin
result type for supported unit-producing body forms rather than making it a
user-visible, storable, comparable, or test-final value.

## Runtime Errors

Runtime traps are process-terminating runtime errors, not user-catchable Slovo
exceptions. Required stderr messages are:

```text
slovo runtime error: array index out of bounds
slovo runtime error: unwrap_some on none
slovo runtime error: unwrap_ok on err
slovo runtime error: unwrap_err on ok
```

Each message is written with a trailing newline. The process exits with code
`1`. `glagol test` reports a top-level test that triggers one of these runtime
errors as a trapped test and exits with code `1`.

## v1.2 Deferrals

Slovo v1.2 does not support mutable string locals, string assignment, string
concatenation, string indexing or slicing, strings inside arrays/structs/
options/results, broader owned or heap strings, user-defined string runtime bindings,
stable string ABI/layout, `print_unit`, user-visible `unit` values, project
mode, imports, packages, or multi-file modules. exp-1 later stages only
`std.string.concat` as a runtime-owned string operation.

## v1.1

Release tag: `v1.1`

Release date: 2026-05-17

## Summary

Slovo v1.1 is a tooling release over the v1 language contract. It does not add
new source language features, broaden the supported fixture set, or relax any
v1 unsupported boundary.

Assuming the matching Glagol v1.1 release implements the Slovo v1.1 toolchain
contract, the stable user-facing tool surface is:

```text
glagol check <file.slo>
glagol fmt <file.slo>
glagol test <file.slo>
glagol build <file.slo> -o <binary>
```

These commands are single-file commands in v1.1. Project mode, package
management, multi-file modules, stdin formatting, write-in-place formatting,
test filtering, cross-compilation, optimization profiles, stable ABI promises,
object/library output, C headers, FFI, LSP, SARIF, and daemon protocols remain
deferred.

## Toolchain Contract

v1.1 productizes the existing v1 language through a predictable CLI contract:

- `check` parses, lowers, and type-checks one Slovo source file without
  producing primary artifacts.
- `fmt` prints canonical formatted source for one file to stdout and does not
  modify the input file.
- `test` runs top-level Slovo tests in one file and reports source failures,
  failed tests, and reported runtime traps as ordinary command failures.
- `build` produces a hosted native executable for the current machine through
  the Glagol LLVM IR plus runtime C plus Clang pipeline.
- `--json-diagnostics` requests newline-delimited JSON diagnostics on stderr.
- `--manifest <path>` requests a `slovo.artifact-manifest` version `1`
  manifest describing the actual invocation outputs.
- `--no-color`, `--help`, and `--version` are common command flags.

Machine diagnostics remain schema `slovo.diagnostic` version `1`. Artifact
manifests remain schema `slovo.artifact-manifest` version `1`.

## Stable Exit Codes

Glagol v1.1 commands use this stable table:

```text
0   success
1   source parse, lowering, type, formatter, test failure, or unsupported form
2   command-line usage error
3   required toolchain component missing or unusable
4   internal compiler error
5   manifest or output artifact write failure
```

A failed Slovo test is exit code `1`. A missing hosted build dependency such as
Clang is exit code `3`. Panics or impossible compiler states on supported
inputs are release blockers and map to exit code `4` only as a containment
path.

## Compatibility Aliases

The canonical documented commands are `check`, `fmt`, `test`, and `build`.

Glagol may retain pre-v1.1 developer commands or flags as compatibility aliases
only when they route through the same diagnostics, manifest, and exit-code
paths as the canonical commands and do not change semantics. Slovo v1.1 does
not treat those aliases as primary user documentation, and exact alias names
remain Glagol release evidence rather than new Slovo language surface.

## Native Build Boundary

`glagol build <file.slo> -o <binary>` is a hosted native build path, not a
stable systems ABI promise. It proves that supported v1 programs can build and
run as direct executables on the current host using documented Glagol runtime C
inputs and the host Clang/linker environment.

Required v1.1 native build smoke coverage includes `add`, `while`, array value
flow, option payload flow, result payload flow, struct value flow, and string
print.

## Release Gates

Slovo-side gate:

```text
git -C slovo diff --check
```

Glagol-side gates for the matching v1.1 release include the baseline test and
format gates, CLI tests for all canonical commands, stable exit-code tests,
JSON diagnostic snapshots, artifact manifest snapshots, hosted native build
smokes, fixture-alignment checks, and release-note review for aliases and
deferrals.

No `v1.1` tag should be cut while required gates are failing, skipped, or
blocked by review.

## v1

Release tag: `v1`

Release date: 2026-05-17

## Summary

Slovo v1 extends the v0 kernel with practical value flow while preserving the
manifest rule: a feature is supported only when the language contract, fixtures,
formatter behavior, diagnostics, tests, and Glagol implementation agree.

v1 keeps native executable output, stable ABI/layout promises, broad runtime
bindings, raw memory, and FFI out of scope. The supported compiler path remains
Slovo source through Glagol to textual LLVM IR, with native execution available
through the explicit LLVM-plus-runtime Clang workflow.

## Supported Fixture Set

These examples define the promoted Slovo v1 surface:

```text
examples/supported/add.slo
examples/supported/top-level-test.slo
examples/supported/local-variables.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/option-result.slo
examples/supported/option-result-flow.slo
examples/supported/option-result-payload.slo
examples/supported/string-print.slo
examples/supported/unsafe.slo
```

Formatter fixtures under `examples/formatter/` define canonical v1 layout,
including the promoted full-line comment stability fixture
`examples/formatter/comments.slo`.

Frozen v0 compatibility fixtures remain under `examples/compat/v0/`.

## Promoted v1 Language Surface

- Struct value flow: immutable struct locals, struct parameters, struct
  returns, calls returning structs, and field access through stored values.
- Fixed array value flow: immutable positive-length arrays over the current
  direct scalar families `i32`, `i64`, `f64`, `bool`, plus `string`, with
  immutable array locals, parameters, returns, calls returning arrays, and
  runtime-checked dynamic indexing on `i32` expressions.
- Option/result value flow for `(option i32)` and `(result i32 i32)`: immutable
  locals, parameters, calls returning option/result values, tag observation, and
  explicit trap-based `i32` payload extraction with `unwrap_some`, `unwrap_ok`,
  and `unwrap_err`.
- Narrow string runtime slice: direct source string literals passed to
  temporary compiler/runtime intrinsic `print_string`.
- Lexical `unsafe` remains the accepted unsafe boundary, without raw memory or
  FFI operations.

### Runtime String Slice

- Promotes the Slovo-side contract for immutable source string literals passed
  directly to temporary compiler/runtime intrinsic `(print_string value)`.
- Defines the first runtime representation as a borrowed immutable
  NUL-terminated byte pointer to compiler-emitted static storage, with no user
  ownership, mutation, allocation, free, stable ABI, or broader runtime binding
  promise.
- Adds `examples/supported/string-print.slo` and
  `examples/formatter/string-print.slo`.

Still deferred at that stage: string locals, string function parameters or
returns, string equality/comparison, strings inside arrays, structs, options,
or results, slices, concatenation, length, indexing, ownership, user-defined
string runtime bindings, and stable string ABI promises. Current exp-19 later
promotes only direct immutable `string` struct fields.

## Tooling Contracts

- Machine diagnostics use `slovo.diagnostic` version `1` with a root
  `(diagnostic ...)` form.
- Artifact manifests use `slovo.artifact-manifest` version `1` for compiler
  outputs and test-report side channels.
- Formatter output is stable for promoted formatter fixtures, preserves accepted
  full-line comment positions, rejects unsupported comment/layout positions
  with structured diagnostics, and does not promise width-based reflow.
- Glagol keeps golden diagnostic fixtures for current explicitly rejected v1
  boundaries and textual lowering-inspector golden fixtures for promoted v1
  feature families.
- Stable LLVM debug metadata, DWARF, standalone source-map files, JSON tooling
  output, direct native output, package layout, and stable ABI/layout remain
  deferred.

## Explicit Deferrals

Slovo v1 does not support:

- struct field/value mutation
- full option/result matching, mapping, equality, printing, nested values,
  non-`i32` payloads, containers, or user-catchable payload traps
- bool or unit printing, user-declared/stored `unit`, or broader standard
  runtime printing
- full string value flow, ownership, slicing, indexing, equality/comparison, or
  user-defined runtime bindings
- array mutation, arrays of unsupported element types, zero-length arrays,
  array equality, printing arrays, nested arrays, unchecked indexing, or
  stable array layout
- pointer types, allocation, deallocation, load/store, pointer arithmetic,
  reinterpretation, raw memory operations, or FFI
- JSON diagnostics or lowering-inspector output
- macros, generics, package management, concurrency, direct machine-code
  backend, stable ABI, or stable layout

## v0

Release tag: `v0`

Release date: 2026-05-16

Release commit: `d7a60ce`

## Summary

Slovo v0 is the first released language contract. It turns the initial
manifest, design laws, and compiler experiments into a strict supported subset
with matching Glagol implementation coverage.

The purpose of v0 is not broad application development. The purpose is to
establish a clean, compiler-backed kernel that can be parsed, formatted,
checked, tested, inspected, lowered, and emitted as LLVM IR.

## Supported Fixture Set

These examples define the compiler-supported Slovo v0 surface:

```text
examples/supported/add.slo
examples/supported/top-level-test.slo
examples/supported/local-variables.slo
examples/supported/if.slo
examples/supported/while.slo
examples/supported/struct.slo
examples/supported/array.slo
examples/supported/option-result.slo
examples/supported/unsafe.slo
```

Formatter fixtures live in `examples/formatter/` and define canonical layout
for the same strict supported syntax.

Frozen copies of the v0 supported and formatter fixtures live under
`examples/compat/v0/` for post-v0 compatibility checks.

Examples under `examples/speculative/` are design targets, not supported v0
compiler fixtures.

## Supported Language Surface

Slovo v0 supports:

- `(module name)`
- top-level `(fn ...)`
- top-level `(test "name" body... final-expression)`
- top-level `(struct Name (field i32)...)`
- explicit `i32` parameters and `i32` returns
- direct `(option i32)` and `(result i32 i32)` constructor returns
- integer literals and parameter references
- binary `+`
- equality comparison `=`
- ordering comparison `<`
- user function calls
- temporary compiler intrinsic `print_i32`
- local `i32` bindings with `let` and `var`
- 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-pass fixed `i32` array construction
- immutable fixed `i32` array locals
- literal checked indexing
- first-pass option/result constructors
- lexical `unsafe` expression blocks containing otherwise supported safe forms

## Compiler Contract

The matching compiler release is Glagol v0. Its implementation-facing surface is
the `glagol` binary CLI.

Glagol can:

- emit LLVM IR for supported programs
- format supported source
- print parsed trees
- inspect surface lowering
- inspect checked lowering
- check top-level tests
- run top-level tests
- emit structured diagnostics for unsupported or invalid source-reachable forms

Native executable output is not part of the Slovo v0 language contract. v0 uses
the explicit Glagol LLVM IR plus Clang runtime-linking workflow.

## Explicit Deferrals

Slovo v0 does not support:

- runtime string values
- dynamic array indices
- runtime array bounds traps
- array parameters, returns, or mutation
- slices
- option/result locals, calls as values, matching, unwrap, equality, or printing
- struct locals, parameters, returns, field mutation, nested fields, recursive
  structs, or methods
- pointer types
- raw allocation and deallocation
- pointer load/store
- pointer arithmetic
- unchecked indexing behavior
- reinterpretation
- FFI
- unsafe abstractions
- stable ABI or layout promises
- macros
- generics
- package management
- ownership or affine resources
- concurrency
- direct machine-code backend

## Post-v0 Direction

Post-v0 work starts in `SPEC-v1.md` and `.llm/V1_ROADMAP.md`.

The first recommended v1 slice is struct value flow: struct locals, parameters,
returns, and field access through stored struct values. This slice should be
specified before implementation and must preserve the v0 support rule.
