Release 1.0.0-beta.7 serialization foundation

.llm/BETA_7_SERIALIZATION_DATA_INTERCHANGE.md

@@ -0,0 +1,61 @@
+# 1.0.0-beta.7 Serialization And Data Interchange Target
+
+Status: released as `1.0.0-beta.7` on 2026-05-22.
+
+`1.0.0-beta.7` targets a deliberately narrow serialization/data-interchange
+foundation after the beta.6 networking slice. The goal is compact JSON text
+construction for CLI, file, and loopback-network programs without pretending
+that Slovo already has the collections and string APIs needed for a complete
+JSON library.
+
+## Slovo Source Surface
+
+The staged source facade is `lib/std/json.slo`, importable explicitly as
+`std.json`.
+
+Exported helpers:
+
+- `quote_string : (string) -> string`
+- `null_value : () -> string`
+- `bool_value : (bool) -> string`
+- `i32_value : (i32) -> string`
+- `u32_value : (u32) -> string`
+- `i64_value : (i64) -> string`
+- `u64_value : (u64) -> string`
+- `f64_value : (f64) -> string`
+- `field_string`, `field_bool`, `field_i32`, `field_u32`, `field_i64`,
+  `field_u64`, `field_f64`, and `field_null`
+- `array0`, `array1`, `array2`, `array3`
+- `object0`, `object1`, `object2`, `object3`
+
+The array and object helpers accept already-encoded JSON text fragments. They
+are compact construction helpers, not recursive data structures.
+
+## Runtime Call
+
+The facade wraps one compiler-known runtime call:
+
+- `std.json.quote_string(value string) -> string`
+
+The hosted runtime symbol is `__glagol_json_quote_string`. It returns a
+complete compact JSON string literal including surrounding quotes. It escapes
+quote, backslash, newline, tab, carriage return, backspace, form feed, and
+other control bytes. Allocation failure uses the existing string allocation
+trap.
+
+## Fixtures And Benchmarks
+
+- `examples/projects/std-import-json/` exercises explicit `std.json` source
+  import.
+- `examples/projects/std-layout-local-json/` mirrors the facade as a local
+  module fixture and keeps the source-search contract explicit.
+- `benchmarks/json-quote-loop/` adds a local-machine timing scaffold for JSON
+  string quoting across Slovo, C, Rust, Python, Clojure, and Common Lisp/SBCL.
+
+## Deferrals
+
+This scope does not add JSON parsing, recursive JSON values, maps/sets, generic
+collections, source-level byte/character scanners, slicing, streaming encoders,
+schema validation, Unicode normalization, embedded NUL support in the current
+null-terminated runtime string ABI, stable runtime helper symbols, stable
+ABI/layout/ownership guarantees, or a stable standard-library API freeze.

.llm/ROADMAP_TO_STABLE.md

@@ -28,7 +28,9 @@ implementation scope.
    concrete numeric completeness.
 5. Expand package/workspace discipline before remote registry work.
 6. Add networking only after resource/error policy is coherent.
-7. Add serialization/data-interchange helpers before richer network libraries.
+7. Add serialization/data-interchange helpers before richer network libraries
+   (released in `1.0.0-beta.7` with compact JSON text construction and JSON
+   string quoting).
 8. Design generics and collection unification from real stdlib duplication
    pressure.
 9. Add editor-facing diagnostics, watch mode, and generated documentation

.llm/reviews/BETA_7_RELEASE_REVIEW.md

@@ -0,0 +1,37 @@
+# 1.0.0-beta.7 Release Review
+
+Date: 2026-05-22
+
+Scope: serialization and data-interchange foundation.
+
+## Verdict
+
+`1.0.0-beta.7` is a coherent beta follow-up slice. The release adds a narrow
+runtime-backed JSON string quoting primitive, a source-authored `std/json.slo`
+facade, explicit std/local example projects, and a `json-quote-loop` benchmark
+scaffold without claiming full JSON parsing, recursive JSON values, maps,
+schema validation, or streaming encoders.
+
+## Review Notes
+
+- The new compiler-known call is intentionally small:
+  `std.json.quote_string(value string) -> string` lowers to
+  `__glagol_json_quote_string` and is listed in unsupported-call diagnostics.
+- The source facade composes existing string and numeric helpers and keeps
+  object/array helpers limited to small fixed arities over already-encoded JSON
+  fragments.
+- The local and std import fixtures preserve the current explicit-import
+  standard-library discipline.
+- The benchmark scaffold is suitable as a local regression/comparison harness,
+  but the whitepapers still treat the exp-123 nine-row table as the current
+  published numeric baseline until fresh full-suite timing is rerun.
+- The hosted runtime escaping path covers quotes, backslashes, standard JSON
+  control escapes, and `\u00XX` for remaining control bytes.
+
+## Remaining Deferred Work
+
+- JSON parsing and recursive JSON value modeling.
+- Maps/sets or generic collection-backed object construction.
+- Streaming encoders and schema-oriented validation.
+- Unicode normalization or code point policy beyond byte-preserving string
+  literal emission.

README.md

@@ -6,7 +6,7 @@ This repository is the canonical public monorepo for the language design,
 standard library source, compiler, runtime, examples, benchmarks, and technical
 documents.
 
-Current release: `1.0.0-beta.6`.
+Current release: `1.0.0-beta.7`.
 
 ## Repository Layout
 
@@ -24,13 +24,14 @@ scripts/        local release and document tooling
 
 ## Beta Scope
 
-`1.0.0-beta.6` keeps the `1.0.0-beta` language baseline, includes the
+`1.0.0-beta.7` keeps the `1.0.0-beta` language baseline, includes the
 `1.0.0-beta.1` tooling/install hardening slice, the `1.0.0-beta.2`
 runtime/resource foundation bundle, the `1.0.0-beta.3` standard-library
 stabilization bundle, the `1.0.0-beta.4` language-usability diagnostics
 bundle, the `1.0.0-beta.5` local package/workspace discipline bundle, and the
-`1.0.0-beta.6` loopback networking foundation. The language baseline supports
+`1.0.0-beta.6` loopback networking foundation, plus the `1.0.0-beta.7`
-practical local command-line programs and libraries with:
+serialization/data-interchange foundation. The language baseline supports
+practical local command-line, file, and loopback-network programs with:
 
 - modules, explicit imports, packages, and local workspaces
 - `new`, `check`, `fmt`, `test`, `doc`, and `build`
@@ -40,6 +41,7 @@ practical local command-line programs and libraries with:
 - explicit `std/*.slo` imports from `lib/std`, installed `share/slovo/std`, or
   `SLOVO_STD_PATH`
 - beta-scoped loopback TCP handles through `std.net`
+- JSON string quoting and compact JSON text construction through `std.json`
 - hosted native builds through LLVM IR, Clang, and `runtime/runtime.c`
 
 Still deferred before stable: generics, maps/sets, broad package registry
@@ -177,6 +179,21 @@ This is not a general networking stack. DNS, TLS, UDP, non-loopback binding,
 async IO, HTTP frameworks, rich host-error ADTs, stable socket ABI/layout, and
 automatic resource ownership remain deferred.
 
+## 1.0.0-beta.7 Serialization And Data Interchange
+
+The `1.0.0-beta.7` release adds a narrow JSON text-construction foundation:
+
+- compiler-known `std.json.quote_string` for deterministic compact JSON string
+  quoting
+- `lib/std/json.slo` source helpers for scalar values, fields, small arrays,
+  and small objects
+- explicit std/local JSON example projects and a `json-quote-loop` benchmark
+  scaffold
+
+This is not a complete JSON library. Full parsing, recursive JSON values,
+maps/sets, streaming encoders, schema validation, Unicode normalization, and a
+stable data-interchange API freeze remain deferred.
+
 ## Documentation
 
 - [Language Manifest](docs/language/MANIFEST.md)

benchmarks/json-quote-loop/.gitignore

@@ -0,0 +1 @@
+build/

benchmarks/json-quote-loop/README.md

@@ -0,0 +1,71 @@
+# JSON Quote Loop Benchmark Scaffold
+
+Release: `1.0.0-beta.7`.
+
+This benchmark compares compact JSON string quoting plus checksum accumulation
+across Slovo, C, Rust, Python, Clojure, and Common Lisp/SBCL on the same
+machine. It is same machine local evidence only.
+
+It is not a published benchmark result, performance threshold, optimizer
+claim, or cross-machine comparison.
+
+## Files
+
+- `src/main.slo`: Slovo project benchmark fixture
+- `c/json_quote_loop.c`: C comparison implementation
+- `rust/json_quote_loop.rs`: Rust comparison implementation
+- `python/json_quote_loop.py`: Python comparison implementation
+- `clojure/json_quote_loop.clj`: Clojure comparison implementation
+- `common-lisp/json_quote_loop.lisp`: Common Lisp/SBCL comparison implementation
+- `run.py`: build/run/timing harness
+
+All implementations print checksum `15000001` for loop count `1000000` and
+target string `slo"vo\path`. Hot-loop mode uses loop count `10000000` and
+checksum `150000001`.
+
+## Commands
+
+Run from the repository root:
+
+```bash
+python3 benchmarks/json-quote-loop/run.py --list
+python3 benchmarks/json-quote-loop/run.py --dry-run
+python3 benchmarks/json-quote-loop/run.py --only python --repeats 3 --warmups 1
+python3 benchmarks/json-quote-loop/run.py --mode hot-loop --only slovo --only c --only rust
+```
+
+To include Slovo, build or point at a Glagol binary and make sure host Clang is
+available:
+
+```bash
+cargo build --manifest-path compiler/Cargo.toml --bin glagol
+python3 benchmarks/json-quote-loop/run.py --glagol compiler/target/debug/glagol
+```
+
+The runner skips missing C/Rust/Slovo/Clojure/SBCL toolchains where possible.
+Use `--only` multiple times to select implementations:
+
+```bash
+python3 benchmarks/json-quote-loop/run.py --only slovo --only c --only rust --only clojure --only common_lisp
+```
+
+Clojure is detected with `clojure` on PATH, `CLOJURE`, or `CLOJURE_JAR`.
+Common Lisp is detected with `sbcl` on PATH, `SBCL`, or `--sbcl`.
+
+## Comparison Method
+
+- The runner builds each implementation once before timing. The reported
+  numbers measure execution only, not compile time.
+- Slovo timings use `glagol build`, which currently lowers to LLVM and then
+  invokes host `clang -O2` with `runtime/runtime.c`.
+- C timings use `clang -O2 -std=c11`.
+- Rust timings use `rustc -C opt-level=3 -C debuginfo=0`.
+- The measured loop quotes one runtime-supplied ASCII string containing a
+  quote and a backslash, then accumulates the quoted byte length.
+
+Timing is cold-process local-machine evidence only. Clojure timings include
+JVM and Clojure startup, while Common Lisp timings include SBCL script
+startup.
+
+Hot-loop mode is startup-amortized local evidence. It runs a larger loop count
+and reports total time plus normalized time for the base `1000000` loop count.

benchmarks/json-quote-loop/benchmark.json

@@ -0,0 +1,11 @@
+{
+  "benchmark": "json-quote-loop",
+  "source_stem": "json_quote_loop",
+  "loop_count": 1000000,
+  "expected_checksum": "15000001",
+  "stdin": "1000000\n",
+  "hot_loop_count": 10000000,
+  "hot_expected_checksum": "150000001",
+  "hot_stdin": "10000000\n",
+  "run_args": ["slo\"vo\\path"]
+}

benchmarks/json-quote-loop/c/json_quote_loop.c

@@ -0,0 +1,118 @@
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define LOOP_COUNT 1000000
+#define EXPECTED_CHECKSUM 15000001
+
+static int32_t configured_loop_count(void) {
+    int32_t value = LOOP_COUNT;
+    if (scanf("%d", &value) != 1 || value <= 0) {
+        return LOOP_COUNT;
+    }
+    return value;
+}
+
+static const char *configured_target(int argc, char **argv) {
+    return argc > 1 ? argv[1] : "slo\"vo\\path";
+}
+
+static char json_hex_digit(unsigned char value) {
+    return value < 10 ? (char)('0' + value) : (char)('A' + (value - 10));
+}
+
+static char *quote_json_string(const char *text) {
+    size_t len = 2;
+    for (const unsigned char *cursor = (const unsigned char *)text; *cursor != '\0'; cursor++) {
+        switch (*cursor) {
+            case '"':
+            case '\\':
+            case '\n':
+            case '\t':
+            case '\r':
+            case '\b':
+            case '\f':
+                len += 2;
+                break;
+            default:
+                len += *cursor < 0x20 ? 6 : 1;
+                break;
+        }
+    }
+
+    char *out = malloc(len + 1);
+    if (out == NULL) {
+        exit(2);
+    }
+
+    char *write = out;
+    *write++ = '"';
+    for (const unsigned char *cursor = (const unsigned char *)text; *cursor != '\0'; cursor++) {
+        switch (*cursor) {
+            case '"':
+                *write++ = '\\';
+                *write++ = '"';
+                break;
+            case '\\':
+                *write++ = '\\';
+                *write++ = '\\';
+                break;
+            case '\n':
+                *write++ = '\\';
+                *write++ = 'n';
+                break;
+            case '\t':
+                *write++ = '\\';
+                *write++ = 't';
+                break;
+            case '\r':
+                *write++ = '\\';
+                *write++ = 'r';
+                break;
+            case '\b':
+                *write++ = '\\';
+                *write++ = 'b';
+                break;
+            case '\f':
+                *write++ = '\\';
+                *write++ = 'f';
+                break;
+            default:
+                if (*cursor < 0x20) {
+                    *write++ = '\\';
+                    *write++ = 'u';
+                    *write++ = '0';
+                    *write++ = '0';
+                    *write++ = json_hex_digit((unsigned char)(*cursor >> 4));
+                    *write++ = json_hex_digit((unsigned char)(*cursor & 0x0F));
+                } else {
+                    *write++ = (char)*cursor;
+                }
+                break;
+        }
+    }
+    *write++ = '"';
+    *write = '\0';
+    return out;
+}
+
+static int32_t json_quote_loop(int32_t limit, const char *target) {
+    int32_t i = 0;
+    int32_t acc = 1;
+
+    while (i < limit) {
+        char *quoted = quote_json_string(target);
+        acc += (int32_t)strlen(quoted);
+        free(quoted);
+        i += 1;
+    }
+
+    return acc;
+}
+
+int main(int argc, char **argv) {
+    int32_t result = json_quote_loop(configured_loop_count(), configured_target(argc, argv));
+    printf("%d\n", result);
+    return result == EXPECTED_CHECKSUM ? 0 : 1;
+}

benchmarks/json-quote-loop/clojure/json_quote_loop.clj

@@ -0,0 +1,42 @@
+(set! *warn-on-reflection* true)
+(set! *unchecked-math* :warn-on-boxed)
+
+(def loop-count 1000000)
+(def expected-checksum 15000001)
+
+(defn configured-loop-count []
+  (try
+    (let [line (read-line)
+          value (Integer/parseInt (.trim ^String line))]
+      (if (pos? value) value loop-count))
+    (catch Exception _
+      loop-count)))
+
+(defn configured-target []
+  (or (first *command-line-args*) "slo\"vo\\path"))
+
+(defn quote-json-string [^String value]
+  (let [builder (StringBuilder.)]
+    (.append builder \")
+    (dotimes [index (.length value)]
+      (let [ch (.charAt value index)]
+        (case ch
+          \" (.append builder "\\\"")
+          \\ (.append builder "\\\\")
+          \newline (.append builder "\\n")
+          \tab (.append builder "\\t")
+          \return (.append builder "\\r")
+          (.append builder ch))))
+    (.append builder \")
+    (.toString builder)))
+
+(defn json-quote-loop [limit target]
+  (loop [i 0
+         acc 1]
+    (if (< i limit)
+      (recur (inc i) (+ acc (.length ^String (quote-json-string target))))
+      acc)))
+
+(let [result (json-quote-loop (configured-loop-count) (configured-target))]
+  (println result)
+  (System/exit (if (= result expected-checksum) 0 1)))

benchmarks/json-quote-loop/common-lisp/json_quote_loop.lisp

@@ -0,0 +1,47 @@
+(declaim (optimize (speed 3) (safety 0) (debug 0)))
+
+(defconstant +loop-count+ 1000000)
+(defconstant +expected-checksum+ 15000001)
+
+(declaim (ftype (function () fixnum) configured-loop-count))
+(defun configured-loop-count ()
+  (handler-case
+      (let ((line (read-line *standard-input* nil nil)))
+        (if line
+            (let ((value (parse-integer line :junk-allowed t)))
+              (if (> value 0) value +loop-count+))
+            +loop-count+))
+    (error () +loop-count+)))
+
+(declaim (ftype (function () string) configured-target))
+(defun configured-target ()
+  (or (second sb-ext:*posix-argv*) "slo\"vo\\path"))
+
+(declaim (ftype (function (string) string) quote-json-string))
+(defun quote-json-string (value)
+  (with-output-to-string (out)
+    (write-char #\" out)
+    (loop for ch across value
+          do (case ch
+               (#\" (write-string "\\\"" out))
+               (#\\ (write-string "\\\\" out))
+               (#\Newline (write-string "\\n" out))
+               (#\Tab (write-string "\\t" out))
+               (#\Return (write-string "\\r" out))
+               (otherwise (write-char ch out))))
+    (write-char #\" out)))
+
+(declaim (ftype (function (fixnum string) fixnum) json-quote-loop))
+(defun json-quote-loop (limit target)
+  (declare (type fixnum limit)
+           (type string target))
+  (loop with i of-type fixnum = 0
+        with acc of-type fixnum = 1
+        while (< i limit)
+        do (setf acc (+ acc (length (quote-json-string target)))
+                 i (+ i 1))
+        finally (return acc)))
+
+(let ((result (json-quote-loop (configured-loop-count) (configured-target))))
+  (format t "~D~%" result)
+  (sb-ext:exit :code (if (= result +expected-checksum+) 0 1)))

benchmarks/json-quote-loop/python/json_quote_loop.py

@@ -0,0 +1,53 @@
+import sys
+
+
+LOOP_COUNT = 1_000_000
+EXPECTED_CHECKSUM = 15_000_001
+
+
+def configured_loop_count() -> int:
+    try:
+        value = int(input().strip())
+    except (EOFError, ValueError):
+        return LOOP_COUNT
+
+    return value if value > 0 else LOOP_COUNT
+
+
+def configured_target() -> str:
+    return sys.argv[1] if len(sys.argv) > 1 else 'slo"vo\\path'
+
+
+def quote_json_string(value: str) -> str:
+    return (
+        '"'
+        + value.replace("\\", "\\\\")
+        .replace('"', '\\"')
+        .replace("\n", "\\n")
+        .replace("\t", "\\t")
+        .replace("\r", "\\r")
+        .replace("\b", "\\b")
+        .replace("\f", "\\f")
+        + '"'
+    )
+
+
+def json_quote_loop(limit: int, target: str) -> int:
+    i = 0
+    acc = 1
+
+    while i < limit:
+        acc += len(quote_json_string(target))
+        i += 1
+
+    return acc
+
+
+def main() -> int:
+    result = json_quote_loop(configured_loop_count(), configured_target())
+    print(result)
+    return 0 if result == EXPECTED_CHECKSUM else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

benchmarks/json-quote-loop/run.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+"""Run the local json-quote-loop benchmark scaffold."""
+
+from pathlib import Path
+import sys
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from runner import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(__file__).resolve().parent, sys.argv[1:]))

benchmarks/json-quote-loop/rust/json_quote_loop.rs

@@ -0,0 +1,62 @@
+use std::io::Read;
+
+const LOOP_COUNT: i32 = 1_000_000;
+const EXPECTED_CHECKSUM: i32 = 15_000_001;
+
+fn configured_loop_count() -> i32 {
+    let mut input = String::new();
+    if std::io::stdin().read_to_string(&mut input).is_err() {
+        return LOOP_COUNT;
+    }
+
+    input
+        .trim()
+        .parse::<i32>()
+        .ok()
+        .filter(|value| *value > 0)
+        .unwrap_or(LOOP_COUNT)
+}
+
+fn configured_target() -> String {
+    std::env::args()
+        .nth(1)
+        .unwrap_or_else(|| "slo\"vo\\path".to_string())
+}
+
+fn quote_json_string(value: &str) -> String {
+    let mut out = String::with_capacity(value.len() + 2);
+    out.push('"');
+    for ch in value.chars() {
+        match ch {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            '\n' => out.push_str("\\n"),
+            '\t' => out.push_str("\\t"),
+            '\r' => out.push_str("\\r"),
+            '\u{08}' => out.push_str("\\b"),
+            '\u{0c}' => out.push_str("\\f"),
+            _ => out.push(ch),
+        }
+    }
+    out.push('"');
+    out
+}
+
+fn json_quote_loop(limit: i32, target: &str) -> i32 {
+    let mut i = 0;
+    let mut acc = 1;
+
+    while i < limit {
+        acc += quote_json_string(target).len() as i32;
+        i += 1;
+    }
+
+    acc
+}
+
+fn main() {
+    let target = configured_target();
+    let result = json_quote_loop(configured_loop_count(), &target);
+    println!("{}", result);
+    std::process::exit(if result == EXPECTED_CHECKSUM { 0 } else { 1 });
+}

benchmarks/json-quote-loop/slovo.toml

@@ -0,0 +1,4 @@
+[project]
+name = "json-quote-loop"
+source_root = "src"
+entry = "main"

benchmarks/json-quote-loop/src/main.slo

@@ -0,0 +1,56 @@
+; Benchmark scaffold fixture for local-machine JSON string quoting comparisons only.
+; Keep LOOP_COUNT and EXPECTED_CHECKSUM aligned with the C/Rust/Python fixtures.
+; The runner supplies the target through argv and the loop count through stdin
+; or argv so the quoting path stays runtime-configured.
+
+(module main)
+
+(fn loop_count () -> i32
+  1000000)
+
+(fn expected_checksum () -> i32
+  15000001)
+
+(fn parse_stdin_loop_count () -> (result i32 i32)
+  (let input (result string i32) (std.io.read_stdin_result))
+  (match input
+    ((ok text)
+      (std.string.parse_i32_result text))
+    ((err code)
+      (err i32 i32 code))))
+
+(fn parse_arg_loop_count () -> (result i32 i32)
+  (std.string.parse_i32_result (std.process.arg 2)))
+
+(fn configured_stdin_loop_count () -> i32
+  (let parsed_stdin (result i32 i32) (parse_stdin_loop_count))
+  (if (is_ok parsed_stdin)
+    (unwrap_ok parsed_stdin)
+    (loop_count)))
+
+(fn configured_loop_count () -> i32
+  (let parsed_arg (result i32 i32) (parse_arg_loop_count))
+  (if (is_ok parsed_arg)
+    (unwrap_ok parsed_arg)
+    (configured_stdin_loop_count)))
+
+(fn target_text () -> string
+  (std.process.arg 1))
+
+(fn json_quote_loop ((limit i32) (target string)) -> i32
+  (var i i32 0)
+  (var acc i32 1)
+  (while (< i limit)
+    (set acc (+ acc (std.string.len (std.json.quote_string target))))
+    (set i (+ i 1)))
+  acc)
+
+(fn main () -> i32
+  (let result i32 (json_quote_loop (configured_loop_count) (target_text)))
+  (std.io.print_i32 result)
+  (if (= result (expected_checksum))
+    0
+    1))
+
+(test "json quote loop checksum is deterministic"
+  (= (json_quote_loop 3 "slo\"vo\\path") 46))

compiler/Cargo.lock

@@ -4,4 +4,4 @@ version = 3
 
 [[package]]
 name = "glagol"
-version = "1.0.0-beta.6"
+version = "1.0.0-beta.7"

compiler/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "glagol"
-version = "1.0.0-beta.6"
+version = "1.0.0-beta.7"
 edition = "2021"
 description = "Glagol, the first compiler for the Slovo language"
 license = "MIT OR Apache-2.0"

compiler/src/llvm.rs

@@ -32,6 +32,7 @@ pub fn emit(_file: &str, program: &CheckedProgram) -> Result<String, Vec<Diagnos
     out.push_str("declare i32 @__glagol_string_parse_u64_result(ptr, ptr)\n\n");
     out.push_str("declare i32 @__glagol_string_parse_f64_result(ptr, ptr)\n\n");
     out.push_str("declare i32 @__glagol_string_parse_bool_result(ptr, ptr)\n\n");
+    out.push_str("declare ptr @__glagol_json_quote_string(ptr)\n\n");
     out.push_str("declare ptr @__glagol_num_i32_to_string(i32)\n\n");
     out.push_str("declare ptr @__glagol_num_i64_to_string(i64)\n\n");
     out.push_str("declare ptr @__glagol_num_u32_to_string(i32)\n\n");

compiler/src/std_runtime.rs

@@ -218,6 +218,13 @@ pub const FUNCTIONS: &[RuntimeFunction] = &[
         return_type: RuntimeType::ResultBoolI32,
         promoted: true,
     },
+    RuntimeFunction {
+        source_name: "std.json.quote_string",
+        runtime_symbol: "__glagol_json_quote_string",
+        params: STRING_PARAM,
+        return_type: RuntimeType::String,
+        promoted: true,
+    },
     RuntimeFunction {
         source_name: "std.io.eprint",
         runtime_symbol: "__glagol_io_eprint",
@@ -740,6 +747,7 @@ const RESERVED_HELPER_SYMBOLS: &[&str] = &[
     "__glagol_string_parse_u64_result",
     "__glagol_string_parse_f64_result",
     "__glagol_string_parse_bool_result",
+    "__glagol_json_quote_string",
     "__glagol_num_u32_to_string",
     "__glagol_num_u64_to_string",
     "__glagol_num_f64_to_string",
@@ -781,7 +789,7 @@ pub fn unsupported_standard_library_call(file: &str, span: Span, source_name: &s
         format!("standard library call `{}` is not supported", source_name),
     )
     .with_span(span)
-    .expected("std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+    .expected("std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
     .found(source_name)
     .hint("use a promoted standard-runtime name or a legacy intrinsic alias")
 }

compiler/src/test_runner.rs

@@ -739,6 +739,26 @@ fn format_f64_to_string(value: f64) -> String {
     text
 }
 
+fn quote_json_string_value(value: &str) -> String {
+    let mut quoted = String::with_capacity(value.len() + 2);
+    quoted.push('"');
+    for byte in value.bytes() {
+        match byte {
+            b'"' => quoted.push_str("\\\""),
+            b'\\' => quoted.push_str("\\\\"),
+            b'\n' => quoted.push_str("\\n"),
+            b'\t' => quoted.push_str("\\t"),
+            b'\r' => quoted.push_str("\\r"),
+            0x08 => quoted.push_str("\\b"),
+            0x0c => quoted.push_str("\\f"),
+            0x00..=0x1f => quoted.push_str(&format!("\\u{byte:04X}")),
+            _ => quoted.push(byte as char),
+        }
+    }
+    quoted.push('"');
+    quoted
+}
+
 fn eval_expr(
     file: &str,
     expr: &TExpr,
@@ -2108,6 +2128,24 @@ fn eval_expr(
                 };
                 return Ok(Value::String(format!("{}{}", left, right)));
             }
+            if runtime_symbol == "__glagol_json_quote_string" {
+                let Some(arg) = args.first() else {
+                    return Err(unsupported_test_expr(
+                        file,
+                        expr,
+                        "malformed `std.json.quote_string` calls",
+                    ));
+                };
+                let value = eval_expr(file, arg, locals, functions, foreign_imports, depth)?;
+                let Some(value) = value.as_string() else {
+                    return Err(unsupported_test_expr(
+                        file,
+                        expr,
+                        "`std.json.quote_string` on non-string values",
+                    ));
+                };
+                return Ok(Value::String(quote_json_string_value(value)));
+            }
             if runtime_symbol == "__glagol_string_parse_i32_result" {
                 let Some(arg) = args.first() else {
                     return Err(unsupported_test_expr(

compiler/tests/benchmark_math_loop_scaffold.rs

@@ -154,6 +154,7 @@ fn benchmark_roots() -> Vec<PathBuf> {
         root.join("math-loop"),
         root.join("branch-loop"),
         root.join("parse-loop"),
+        root.join("json-quote-loop"),
         root.join("array-index-loop"),
         root.join("string-eq-loop"),
         root.join("array-struct-field-loop"),

compiler/tests/promotion_gate.rs

@@ -1163,6 +1163,43 @@ const STANDARD_NET_RUNTIME_NAMES: &[&str] = &[
     "std.net.tcp_close_result",
 ];
 
+const STANDARD_JSON_SOURCE_FACADE_ALPHA: &[&str] = &[
+    "quote_string",
+    "null_value",
+    "bool_value",
+    "i32_value",
+    "u32_value",
+    "i64_value",
+    "u64_value",
+    "f64_value",
+    "field_string",
+    "field_bool",
+    "field_i32",
+    "field_u32",
+    "field_i64",
+    "field_u64",
+    "field_f64",
+    "field_null",
+    "array0",
+    "array1",
+    "array2",
+    "array3",
+    "object0",
+    "object1",
+    "object2",
+    "object3",
+];
+
+const STANDARD_JSON_RUNTIME_NAMES: &[&str] = &[
+    "std.json.quote_string",
+    "std.string.concat",
+    "std.num.i32_to_string",
+    "std.num.u32_to_string",
+    "std.num.i64_to_string",
+    "std.num.u64_to_string",
+    "std.num.f64_to_string",
+];
+
 const STANDARD_PROCESS_SOURCE_FACADE_ALPHA: &[&str] = &[
     "argc",
     "arg",
@@ -1738,6 +1775,7 @@ fn promotion_gate_artifacts_are_aligned() {
     let glagol_project_std_layout_local_env = repo.join("examples/projects/std-layout-local-env");
     let glagol_project_std_layout_local_fs = repo.join("examples/projects/std-layout-local-fs");
     let glagol_project_std_layout_local_net = repo.join("examples/projects/std-layout-local-net");
+    let glagol_project_std_layout_local_json = repo.join("examples/projects/std-layout-local-json");
     let glagol_project_std_layout_local_io = repo.join("examples/projects/std-layout-local-io");
     let glagol_project_std_layout_local_cli = repo.join("examples/projects/std-layout-local-cli");
     let glagol_project_std_layout_local_vec_i32 =
@@ -1758,6 +1796,7 @@ fn promotion_gate_artifacts_are_aligned() {
     let glagol_project_std_import_env = repo.join("examples/projects/std-import-env");
     let glagol_project_std_import_fs = repo.join("examples/projects/std-import-fs");
     let glagol_project_std_import_net = repo.join("examples/projects/std-import-net");
+    let glagol_project_std_import_json = repo.join("examples/projects/std-import-json");
     let glagol_project_std_import_process = repo.join("examples/projects/std-import-process");
     let glagol_project_std_import_string = repo.join("examples/projects/std-import-string");
     let glagol_project_std_import_num = repo.join("examples/projects/std-import-num");
@@ -1772,6 +1811,7 @@ fn promotion_gate_artifacts_are_aligned() {
     let glagol_benchmark_math_loop = repo.join("benchmarks/math-loop");
     let glagol_benchmark_branch_loop = repo.join("benchmarks/branch-loop");
     let glagol_benchmark_parse_loop = repo.join("benchmarks/parse-loop");
+    let glagol_benchmark_json_quote_loop = repo.join("benchmarks/json-quote-loop");
     let glagol_benchmark_array_index_loop = repo.join("benchmarks/array-index-loop");
     let glagol_benchmark_string_eq_loop = repo.join("benchmarks/string-eq-loop");
     let glagol_benchmark_array_struct_field_loop = repo.join("benchmarks/array-struct-field-loop");
@@ -2110,6 +2150,7 @@ fn promotion_gate_artifacts_are_aligned() {
     assert_project_std_import_env_tooling_matches_fixture(&glagol_project_std_import_env);
     assert_project_std_import_fs_tooling_matches_fixture(&glagol_project_std_import_fs);
     assert_project_std_import_net_tooling_matches_fixture(&glagol_project_std_import_net);
+    assert_project_std_import_json_tooling_matches_fixture(&glagol_project_std_import_json);
     assert_project_std_import_process_tooling_matches_fixture(&glagol_project_std_import_process);
     assert_project_std_import_string_tooling_matches_fixture(&glagol_project_std_import_string);
     assert_project_std_import_num_tooling_matches_fixture(&glagol_project_std_import_num);
@@ -2151,6 +2192,9 @@ fn promotion_gate_artifacts_are_aligned() {
     assert_project_std_layout_local_net_tooling_matches_fixture(
         &glagol_project_std_layout_local_net,
     );
+    assert_project_std_layout_local_json_tooling_matches_fixture(
+        &glagol_project_std_layout_local_json,
+    );
     assert_project_std_layout_local_io_tooling_matches_fixture(&glagol_project_std_layout_local_io);
     assert_project_std_layout_local_cli_tooling_matches_fixture(
         &glagol_project_std_layout_local_cli,
@@ -2181,6 +2225,11 @@ fn promotion_gate_artifacts_are_aligned() {
         "parse-loop",
         "parse_loop",
     );
+    assert_named_benchmark_scaffold_is_promotable(
+        &glagol_benchmark_json_quote_loop,
+        "json-quote-loop",
+        "json_quote_loop",
+    );
     assert_named_benchmark_scaffold_is_promotable(
         &glagol_benchmark_array_index_loop,
         "array-index-loop",
@@ -3337,6 +3386,7 @@ fn assert_slovo_std_source_layout_alpha(repo: &Path, std_dir: &Path) {
             std_dir.join("env.slo"),
             std_dir.join("fs.slo"),
             std_dir.join("io.slo"),
+            std_dir.join("json.slo"),
             std_dir.join("math.slo"),
             std_dir.join("net.slo"),
             std_dir.join("num.slo"),
@@ -3368,6 +3418,7 @@ fn assert_slovo_std_source_layout_alpha(repo: &Path, std_dir: &Path) {
         "fs.slo",
         "math.slo",
         "net.slo",
+        "json.slo",
         "num.slo",
         "option.slo",
         "process.slo",
@@ -3385,6 +3436,7 @@ fn assert_slovo_std_source_layout_alpha(repo: &Path, std_dir: &Path) {
             && file != "env.slo"
             && file != "fs.slo"
             && file != "io.slo"
+            && file != "json.slo"
             && file != "process.slo"
             && file != "string.slo"
             && file != "vec_i32.slo"
@@ -4274,6 +4326,54 @@ fn assert_slovo_std_source_layout_alpha(repo: &Path, std_dir: &Path) {
             helper
         );
     }
+
+    let local_json = repo.join("examples/projects/std-layout-local-json/src/json.slo");
+    let slovo_json = read(&std_dir.join("json.slo"));
+    let glagol_json = read(&local_json);
+    assert!(
+        slovo_json.contains("(module json") && glagol_json.contains("(module json"),
+        "both Slovo std/json.slo and the Glagol local fixture should use explicit `json` module source shape"
+    );
+    for runtime_name in STANDARD_JSON_RUNTIME_NAMES {
+        assert!(
+            slovo_json.contains(runtime_name) && glagol_json.contains(runtime_name),
+            "standard json facade must stay backed by `{}`",
+            runtime_name
+        );
+    }
+    assert_std_only_contains(
+        &slovo_json,
+        STANDARD_JSON_RUNTIME_NAMES,
+        "Slovo std/json.slo must not introduce other compiler-known std names",
+    );
+    assert_std_only_contains(
+        &glagol_json,
+        STANDARD_JSON_RUNTIME_NAMES,
+        "Glagol local json fixture must not introduce other compiler-known std names",
+    );
+    for source in [&slovo_json, &glagol_json] {
+        assert!(
+            !source.contains("parse")
+                && !source.contains("token")
+                && !source.contains("map")
+                && !source.contains("unicode")
+                && !source.contains("schema")
+                && !source.contains("stream"),
+            "standard json facade must not claim deferred parser or richer data policies"
+        );
+    }
+    for helper in STANDARD_JSON_SOURCE_FACADE_ALPHA {
+        assert!(
+            slovo_json.contains(&format!("(fn {} ", helper)),
+            "Slovo std/json.slo is missing beta7 facade `{}`",
+            helper
+        );
+        assert!(
+            glagol_json.contains(&format!("(fn {} ", helper)),
+            "Glagol local json fixture is missing beta7 facade `{}`",
+            helper
+        );
+    }
 }
 
 fn assert_source_shaped_file(path: &Path) {
@@ -7107,6 +7207,22 @@ fn assert_project_std_import_net_tooling_matches_fixture(project: &Path) {
     );
 }
 
+fn assert_project_std_import_json_tooling_matches_fixture(project: &Path) {
+    assert_project_std_import_host_facade_tooling_matches_fixture(
+        project,
+        "json",
+        STANDARD_JSON_SOURCE_FACADE_ALPHA,
+        concat!(
+            "test \"explicit std json quote escapes facade\" ... ok\n",
+            "test \"explicit std json scalar values facade\" ... ok\n",
+            "test \"explicit std json fields facade\" ... ok\n",
+            "test \"explicit std json arrays objects facade\" ... ok\n",
+            "test \"explicit std json facade all\" ... ok\n",
+            "5 test(s) passed\n",
+        ),
+    );
+}
+
 fn assert_project_std_import_process_tooling_matches_fixture(project: &Path) {
     assert_project_std_import_host_facade_shape(
         project,
@@ -9271,6 +9387,82 @@ fn assert_standard_net_source_facade_alpha(project: &Path) {
     }
 }
 
+fn assert_project_std_layout_local_json_tooling_matches_fixture(project: &Path) {
+    assert!(project.join("slovo.toml").is_file());
+    assert!(project.join("src/json.slo").is_file());
+    assert!(project.join("src/main.slo").is_file());
+    assert_standard_json_source_facade_alpha(project);
+
+    let check = run_glagol([OsStr::new("check"), project.as_os_str()]);
+    assert_success_stdout(check, "", "std layout local json project check");
+
+    let test = run_glagol([OsStr::new("test"), project.as_os_str()]);
+    assert_success_stdout(
+        test,
+        concat!(
+            "test \"explicit local json quote escapes facade\" ... ok\n",
+            "test \"explicit local json scalar values facade\" ... ok\n",
+            "test \"explicit local json fields facade\" ... ok\n",
+            "test \"explicit local json arrays objects facade\" ... ok\n",
+            "test \"explicit local json facade all\" ... ok\n",
+            "5 test(s) passed\n",
+        ),
+        "std layout local json project test",
+    );
+}
+
+fn assert_standard_json_source_facade_alpha(project: &Path) {
+    let json_source = read(&project.join("src/json.slo"));
+    let main = read(&project.join("src/main.slo"));
+
+    assert!(
+        json_source.starts_with("(module json (export "),
+        "local json fixture must stay an explicitly exported local module"
+    );
+    assert!(
+        main.starts_with("(module main)\n\n(import json ("),
+        "local json fixture must stay an explicit local import"
+    );
+    assert!(
+        !main.contains("(import std") && !main.contains("(import slovo.std"),
+        "standard json source facade fixture must not use automatic std imports"
+    );
+    for runtime_name in STANDARD_JSON_RUNTIME_NAMES {
+        assert!(
+            json_source.contains(runtime_name),
+            "standard json source facade fixture must wrap or compose `{}`",
+            runtime_name
+        );
+    }
+    assert_std_only_contains(
+        &json_source,
+        STANDARD_JSON_RUNTIME_NAMES,
+        "standard json source facade fixture must use only approved std runtime names directly",
+    );
+    assert!(
+        !main.contains("std.")
+            && !json_source.contains("parse")
+            && !json_source.contains("token")
+            && !json_source.contains("map")
+            && !json_source.contains("unicode")
+            && !json_source.contains("schema")
+            && !json_source.contains("stream"),
+        "standard json source facade fixture must remain local and must not claim deferred JSON policies"
+    );
+    for helper in STANDARD_JSON_SOURCE_FACADE_ALPHA {
+        assert!(
+            json_source.contains(&format!("(fn {} ", helper)),
+            "local json fixture is missing facade `{}`",
+            helper
+        );
+        assert!(
+            main.contains(helper),
+            "main fixture import/use is missing facade `{}`",
+            helper
+        );
+    }
+}
+
 fn assert_project_std_layout_local_io_tooling_matches_fixture(project: &Path) {
     assert!(project.join("slovo.toml").is_file());
     assert!(project.join("src/io.slo").is_file());

compiler/tests/standard_json.rs

@@ -0,0 +1,226 @@
+use std::{
+    env,
+    ffi::OsStr,
+    fs,
+    path::{Path, PathBuf},
+    process::{Command, Output},
+    sync::atomic::{AtomicUsize, Ordering},
+};
+
+static NEXT_FIXTURE_ID: AtomicUsize = AtomicUsize::new(0);
+
+#[test]
+fn standard_json_lowers_to_private_runtime_helper() {
+    let fixture = write_fixture(
+        "lowering",
+        r#"
+(module main)
+
+(fn main () -> i32
+  (if (= (std.json.quote_string "slo\"vo") "\"slo\\\"vo\"")
+    0
+    1))
+"#,
+    );
+    let output = run_glagol([fixture.as_os_str()]);
+    assert_success("compile standard json lowering", &output);
+    let stdout = String::from_utf8_lossy(&output.stdout);
+
+    assert!(
+        stdout.contains("declare ptr @__glagol_json_quote_string(ptr)")
+            && stdout.contains("call ptr @__glagol_json_quote_string(")
+            && !stdout.contains("@std.json.quote_string"),
+        "standard json LLVM shape drifted\nstdout:\n{}",
+        stdout
+    );
+}
+
+#[test]
+fn test_runner_reports_deterministic_json_quoting() {
+    let fixture = write_fixture(
+        "test-runner",
+        r#"
+(module main)
+
+(test "quote plain string"
+  (= (std.json.quote_string "slovo") "\"slovo\""))
+
+(test "quote embedded quote"
+  (= (std.json.quote_string "slo\"vo") "\"slo\\\"vo\""))
+
+(test "quote backslash"
+  (= (std.json.quote_string "slo\\vo") "\"slo\\\\vo\""))
+
+(test "quote newline tab"
+  (= (std.json.quote_string "line\n\tnext") "\"line\\n\\tnext\""))
+"#,
+    );
+    let output = run_glagol([OsStr::new("test"), fixture.as_os_str()]);
+    assert_success("run standard json tests", &output);
+    assert_eq!(
+        String::from_utf8_lossy(&output.stdout),
+        concat!(
+            "test \"quote plain string\" ... ok\n",
+            "test \"quote embedded quote\" ... ok\n",
+            "test \"quote backslash\" ... ok\n",
+            "test \"quote newline tab\" ... ok\n",
+            "4 test(s) passed\n",
+        ),
+        "standard json test runner stdout drifted"
+    );
+}
+
+#[test]
+fn standard_json_diagnostics_cover_promoted_and_deferred_names() {
+    let cases = [
+        (
+            "quote-arity",
+            r#"
+(module main)
+
+(fn main () -> i32
+  (std.json.quote_string))
+"#,
+            "ArityMismatch",
+        ),
+        (
+            "quote-type",
+            r#"
+(module main)
+
+(fn main () -> i32
+  (std.json.quote_string 42)
+  0)
+"#,
+            "TypeMismatch",
+        ),
+        (
+            "parse-object-deferred",
+            r#"
+(module main)
+
+(fn main () -> i32
+  (std.json.parse_object_result "{}"))
+"#,
+            "UnsupportedStandardLibraryCall",
+        ),
+        (
+            "promoted-shadow",
+            r#"
+(module main)
+
+(fn std.json.quote_string ((value string)) -> string
+  value)
+
+(fn main () -> i32
+  (if (= (std.json.quote_string "x") "\"x\"") 0 1))
+"#,
+            "DuplicateFunction",
+        ),
+    ];
+
+    for (name, source, diagnostic) in cases {
+        let fixture = write_fixture(name, source);
+        let output = run_glagol([fixture.as_os_str()]);
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let stderr = String::from_utf8_lossy(&output.stderr);
+
+        assert!(
+            !output.status.success(),
+            "compiler unexpectedly accepted `{}`\nstdout:\n{}\nstderr:\n{}",
+            name,
+            stdout,
+            stderr
+        );
+        assert!(
+            stdout.is_empty(),
+            "rejected compile wrote stdout:\n{}",
+            stdout
+        );
+        assert!(
+            stderr.contains(diagnostic),
+            "diagnostic `{}` was not reported for `{}`\nstderr:\n{}",
+            diagnostic,
+            name,
+            stderr
+        );
+    }
+}
+
+#[test]
+fn hosted_json_quote_smoke_when_clang_is_available() {
+    if !clang_is_available() {
+        eprintln!("skipping standard json runtime smoke: set GLAGOL_CLANG or install clang");
+        return;
+    }
+
+    let fixture = write_fixture(
+        "hosted",
+        r#"
+(module main)
+
+(fn main () -> i32
+  (if (= (std.json.quote_string "line\nnext") "\"line\\nnext\"")
+    0
+    1))
+"#,
+    );
+    let binary = fixture.with_extension(env::consts::EXE_EXTENSION);
+    let build = run_glagol([
+        OsStr::new("build"),
+        fixture.as_os_str(),
+        OsStr::new("-o"),
+        binary.as_os_str(),
+    ]);
+    assert_success("build standard json hosted smoke", &build);
+
+    let run = Command::new(&binary)
+        .output()
+        .unwrap_or_else(|err| panic!("run `{}`: {}", binary.display(), err));
+    assert_success("run standard json hosted smoke", &run);
+}
+
+fn write_fixture(name: &str, source: &str) -> PathBuf {
+    let id = NEXT_FIXTURE_ID.fetch_add(1, Ordering::Relaxed);
+    let dir = env::temp_dir().join(format!("glagol-standard-json-{id}-{name}"));
+    fs::create_dir_all(&dir).unwrap_or_else(|err| panic!("create `{}`: {}", dir.display(), err));
+    let path = dir.join("main.slo");
+    fs::write(&path, source).unwrap_or_else(|err| panic!("write `{}`: {}", path.display(), err));
+    path
+}
+
+fn clang_is_available() -> bool {
+    if env::var_os("GLAGOL_CLANG").is_some() {
+        return true;
+    }
+    Command::new("clang")
+        .arg("--version")
+        .output()
+        .is_ok_and(|output| output.status.success())
+}
+
+fn run_glagol<I, S>(args: I) -> Output
+where
+    I: IntoIterator<Item = S>,
+    S: AsRef<std::ffi::OsStr>,
+{
+    Command::new(env!("CARGO_BIN_EXE_glagol"))
+        .args(args)
+        .current_dir(Path::new(env!("CARGO_MANIFEST_DIR")))
+        .output()
+        .expect("run glagol")
+}
+
+fn assert_success(context: &str, output: &Output) {
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    assert!(
+        output.status.success(),
+        "{} failed\nstdout:\n{}\nstderr:\n{}",
+        context,
+        stdout,
+        stderr
+    );
+    assert!(stderr.is_empty(), "{} wrote stderr:\n{}", context, stderr);
+}

compiler/tests/standard_json_source_facade_alpha.rs

@@ -0,0 +1,249 @@
+use std::{
+    ffi::OsStr,
+    fs,
+    path::Path,
+    process::{Command, Output},
+};
+
+const EXPECTED_LOCAL_TEST_OUTPUT: &str = concat!(
+    "test \"explicit local json quote escapes facade\" ... ok\n",
+    "test \"explicit local json scalar values facade\" ... ok\n",
+    "test \"explicit local json fields facade\" ... ok\n",
+    "test \"explicit local json arrays objects facade\" ... ok\n",
+    "test \"explicit local json facade all\" ... ok\n",
+    "5 test(s) passed\n",
+);
+
+const EXPECTED_STD_IMPORT_TEST_OUTPUT: &str = concat!(
+    "test \"explicit std json quote escapes facade\" ... ok\n",
+    "test \"explicit std json scalar values facade\" ... ok\n",
+    "test \"explicit std json fields facade\" ... ok\n",
+    "test \"explicit std json arrays objects facade\" ... ok\n",
+    "test \"explicit std json facade all\" ... ok\n",
+    "5 test(s) passed\n",
+);
+
+const STANDARD_JSON_SOURCE_FACADE_ALPHA: &[&str] = &[
+    "quote_string",
+    "null_value",
+    "bool_value",
+    "i32_value",
+    "u32_value",
+    "i64_value",
+    "u64_value",
+    "f64_value",
+    "field_string",
+    "field_bool",
+    "field_i32",
+    "field_u32",
+    "field_i64",
+    "field_u64",
+    "field_f64",
+    "field_null",
+    "array0",
+    "array1",
+    "array2",
+    "array3",
+    "object0",
+    "object1",
+    "object2",
+    "object3",
+];
+
+const STANDARD_JSON_RUNTIME_NAMES: &[&str] = &[
+    "std.json.quote_string",
+    "std.string.concat",
+    "std.num.i32_to_string",
+    "std.num.u32_to_string",
+    "std.num.i64_to_string",
+    "std.num.u64_to_string",
+    "std.num.f64_to_string",
+];
+
+#[test]
+fn standard_json_source_facade_project_checks_formats_and_tests() {
+    let project =
+        Path::new(env!("CARGO_MANIFEST_DIR")).join("../examples/projects/std-layout-local-json");
+
+    assert_local_json_fixture_is_source_authored(&project);
+
+    let fmt = run_glagol([
+        OsStr::new("fmt"),
+        OsStr::new("--check"),
+        project.as_os_str(),
+    ]);
+    assert_success("std layout local json fmt --check", &fmt);
+
+    let check = run_glagol([OsStr::new("check"), project.as_os_str()]);
+    assert_success_stdout(check, "", "std layout local json check");
+
+    let test = run_glagol([OsStr::new("test"), project.as_os_str()]);
+    assert_success_stdout(
+        test,
+        EXPECTED_LOCAL_TEST_OUTPUT,
+        "std layout local json test output",
+    );
+}
+
+#[test]
+fn standard_json_std_import_project_checks_formats_and_tests() {
+    let project =
+        Path::new(env!("CARGO_MANIFEST_DIR")).join("../examples/projects/std-import-json");
+
+    assert_std_import_json_fixture_uses_repo_std(&project);
+
+    let fmt = run_glagol([
+        OsStr::new("fmt"),
+        OsStr::new("--check"),
+        project.as_os_str(),
+    ]);
+    assert_success("std import json fmt --check", &fmt);
+
+    let check = run_glagol([OsStr::new("check"), project.as_os_str()]);
+    assert_success_stdout(check, "", "std import json check");
+
+    let test = run_glagol([OsStr::new("test"), project.as_os_str()]);
+    assert_success_stdout(
+        test,
+        EXPECTED_STD_IMPORT_TEST_OUTPUT,
+        "std import json test output",
+    );
+}
+
+fn assert_local_json_fixture_is_source_authored(project: &Path) {
+    let json = read(&project.join("src/json.slo"));
+    let main = read(&project.join("src/main.slo"));
+
+    assert!(
+        json.starts_with("(module json (export "),
+        "json.slo must stay an explicit local module export"
+    );
+    assert!(
+        main.starts_with("(module main)\n\n(import json ("),
+        "main.slo must stay an explicit local json import"
+    );
+    assert!(
+        !main.contains("(import std") && !main.contains("(import slovo.std"),
+        "json fixture must not depend on automatic or package std imports"
+    );
+    assert_json_source_shape(&json, &main, "local json fixture");
+    assert!(
+        !main.contains("std."),
+        "local json main fixture must use only local imports"
+    );
+}
+
+fn assert_std_import_json_fixture_uses_repo_std(project: &Path) {
+    let std_json = read(&Path::new(env!("CARGO_MANIFEST_DIR")).join("../lib/std/json.slo"));
+    let main = read(&project.join("src/main.slo"));
+
+    assert!(
+        !project.join("src/json.slo").exists(),
+        "std import json fixture must use repo-root std/json.slo, not a local copy"
+    );
+    assert!(
+        main.starts_with("(module main)\n\n(import std.json ("),
+        "std import json fixture must use explicit `std.json` import syntax"
+    );
+    assert_json_source_shape(&std_json, &main, "repo std.json fixture");
+}
+
+fn assert_json_source_shape(json: &str, main: &str, context: &str) {
+    for runtime_name in STANDARD_JSON_RUNTIME_NAMES {
+        assert!(
+            json.contains(runtime_name),
+            "{} must wrap or compose `{}`",
+            context,
+            runtime_name
+        );
+    }
+    assert_std_only_contains(json, STANDARD_JSON_RUNTIME_NAMES, context);
+    assert!(
+        !json.contains("parse")
+            && !json.contains("token")
+            && !json.contains("map")
+            && !json.contains("unicode")
+            && !json.contains("schema")
+            && !json.contains("stream")
+            && !main.contains("parse")
+            && !main.contains("token")
+            && !main.contains("map")
+            && !main.contains("unicode")
+            && !main.contains("schema")
+            && !main.contains("stream"),
+        "{} must not claim deferred JSON parsing or richer data APIs",
+        context
+    );
+
+    for helper in STANDARD_JSON_SOURCE_FACADE_ALPHA {
+        assert!(
+            json.contains(&format!("(fn {} ", helper)),
+            "{} is missing source facade `{}`",
+            context,
+            helper
+        );
+        assert!(
+            main.contains(helper),
+            "{} main fixture import/use is missing `{}`",
+            context,
+            helper
+        );
+    }
+}
+
+fn assert_std_only_contains(source: &str, allowed: &[&str], context: &str) {
+    let mut remaining = source.to_string();
+    for name in allowed {
+        remaining = remaining.replace(name, "");
+    }
+    assert!(
+        !remaining.contains("std."),
+        "{} introduced unexpected compiler-known std names",
+        context
+    );
+}
+
+fn run_glagol<I, S>(args: I) -> Output
+where
+    I: IntoIterator<Item = S>,
+    S: AsRef<std::ffi::OsStr>,
+{
+    Command::new(env!("CARGO_BIN_EXE_glagol"))
+        .args(args)
+        .current_dir(Path::new(env!("CARGO_MANIFEST_DIR")))
+        .output()
+        .expect("run glagol")
+}
+
+fn read(path: &Path) -> String {
+    fs::read_to_string(path).unwrap_or_else(|err| panic!("read `{}`: {}", path.display(), err))
+}
+
+fn assert_success(context: &str, output: &Output) {
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    assert!(
+        output.status.success(),
+        "{} failed\nstdout:\n{}\nstderr:\n{}",
+        context,
+        stdout,
+        stderr
+    );
+    assert!(stderr.is_empty(), "{} wrote stderr:\n{}", context, stderr);
+}
+
+fn assert_success_stdout(output: Output, expected: &str, context: &str) {
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    assert!(
+        output.status.success(),
+        "{} failed\nstdout:\n{}\nstderr:\n{}",
+        context,
+        stdout,
+        stderr
+    );
+    assert_eq!(stdout, expected, "{} stdout drifted", context);
+    assert!(stderr.is_empty(), "{} wrote stderr:\n{}", context, stderr);
+}

docs/POST_BETA_ROADMAP.md

@@ -181,6 +181,16 @@ Work:
   collections exist
 - add benchmark cases for parsing and formatting
 
+Released in `1.0.0-beta.7`: `lib/std/json.slo` now provides explicit helpers
+for compact JSON text construction over strings, booleans, numbers, null,
+fields, small arrays, and small objects. `std.json.quote_string` is a
+compiler-known runtime helper so JSON string escaping is correct before Slovo
+has source-level byte/character scanning and slicing. Matching explicit
+std/local source fixtures and a `json-quote-loop` benchmark scaffold are in
+place. JSON parsing, recursive JSON values, maps/sets, generic collections,
+streaming encoders, schema validation, Unicode normalization, and stable text
+encoding policy beyond the current runtime string ABI remain deferred.
+
 Why seventh: networking and CLI tools need data interchange, but a complete JSON
 library depends on collection work.
 

docs/compiler/RELEASE_NOTES.md

@@ -12,6 +12,32 @@ integration/readiness release, not the first real beta.
 
 No unreleased changes yet.
 
+## 1.0.0-beta.7
+
+Release label: `1.0.0-beta.7`
+
+Release date: 2026-05-22
+
+Release state: serialization/data-interchange beta update
+
+### Summary
+
+Glagol `1.0.0-beta.7` keeps the `1.0.0-beta` compiler support baseline and
+adds the first narrow JSON construction foundation:
+
+- compiler-known `std.json.quote_string`
+- POSIX-hosted runtime support through `__glagol_json_quote_string`
+- deterministic interpreter/test-runner behavior for JSON quoting tests
+- focused lowering, diagnostics, source-facade, promotion, hosted runtime, and
+  benchmark-scaffold coverage
+
+### Explicit Deferrals
+
+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`

docs/compiler/ROADMAP.md

@@ -22,15 +22,17 @@ general-purpose beta release.
 
 A Glagol feature is done only when it has parser/lowerer support, checker behavior, diagnostics for invalid forms, backend behavior or explicit unsupported diagnostics, and tests.
 
-Current stage: `1.0.0-beta.6`, released on 2026-05-22 as the first post-beta
+Current stage: `1.0.0-beta.7`, released on 2026-05-22 as the first post-beta
-networking foundation update. It keeps the `1.0.0-beta` language/compiler
+serialization/data-interchange foundation update. It keeps the `1.0.0-beta` language/compiler
 support baseline and includes the `1.0.0-beta.1` tooling hardening release, the
 `1.0.0-beta.2` runtime/resource foundation release, the `1.0.0-beta.3`
 standard-library stabilization release, the `1.0.0-beta.4`
 language-usability diagnostics release, the `1.0.0-beta.5` package/workspace
 discipline release, and the `1.0.0-beta.6` compiler-known `std.net` loopback
 TCP runtime family with focused lowering, interpreter, diagnostics,
-source-facade, promotion, and hosted smoke coverage.
+source-facade, promotion, and hosted smoke coverage, plus the `1.0.0-beta.7`
+compiler-known `std.json.quote_string` runtime family with matching
+source-facade, test-runner, hosted smoke, and benchmark-scaffold coverage.
 
 The final experimental precursor scope is `exp-125`. Its unsigned direct-value
 flow, parse/format runtime lanes, and matching staged stdlib helper breadth

docs/language/RELEASE_NOTES.md

@@ -8,19 +8,47 @@ Historical `exp-*` releases listed here are experimental maturity milestones.
 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.6`, published on 2026-05-22. It keeps the
+The current release is `1.0.0-beta.7`, 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`.
+loopback networking foundation bundle from `1.0.0-beta.6`, and the first
+serialization/data-interchange foundation bundle from `1.0.0-beta.7`.
 
 ## Unreleased
 
 No unreleased changes yet.
 
+## 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`

docs/language/ROADMAP.md

@@ -10,16 +10,18 @@ Long-horizon planning lives in
 release train from the historical `v2.0.0-beta.1` tag toward and beyond the
 first real general-purpose beta Slovo contract.
 
-Current stage: `1.0.0-beta.6`, released on 2026-05-22 as the first post-beta
+Current stage: `1.0.0-beta.7`, released on 2026-05-22 as the first post-beta
-networking foundation update. It keeps the `1.0.0-beta` language contract and
+serialization/data-interchange foundation update. It keeps the `1.0.0-beta` language contract and
 includes the `1.0.0-beta.1` tooling hardening release, the `1.0.0-beta.2`
 runtime/resource foundation release, the `1.0.0-beta.3` standard-library
 stabilization release, the `1.0.0-beta.4` language-usability diagnostics
 release, the `1.0.0-beta.5` package/workspace discipline release, and a narrow
 `std.net` source facade for blocking loopback TCP client/server primitives over
-opaque `i32` handles and concrete `result` families. DNS, TLS, UDP, async IO,
+opaque `i32` handles and concrete `result` families, plus a narrow `std.json`
-non-loopback binding, HTTP frameworks, rich host-error ADTs, stable socket
+source facade for compact JSON text construction. JSON parsing, recursive JSON
-ABI/layout, and a stable standard-library API freeze remain deferred.
+values, maps/sets, DNS, TLS, UDP, async IO, non-loopback binding, HTTP
+frameworks, rich host-error ADTs, stable ABI/layout, and a stable
+standard-library API freeze remain deferred.
 
 The final experimental precursor scope is `exp-125`, defined in
 `.llm/EXP_125_UNSIGNED_U32_U64_NUMERIC_AND_STDLIB_BREADTH_ALPHA.md`. Its

docs/language/SPEC-v1.md

@@ -1076,6 +1076,38 @@ timeouts, buffering policy, HTTP frameworks, platform-specific error codes,
 rich host-error ADTs, stable runtime helper symbols, stable socket ABI/layout,
 automatic cleanup, and affine ownership guarantees remain deferred.
 
+### 4.4.5 Post-Beta Serialization Foundation
+
+Status: released in `1.0.0-beta.7`.
+
+The `1.0.0-beta.7` serialization foundation stages compact JSON text
+construction only. It does not change source syntax.
+
+The source facade is `lib/std/json.slo`, imported explicitly as `std.json`.
+It exposes:
+
+```text
+std.json.quote_string: (string) -> string
+std.json.null_value: () -> string
+std.json.bool_value: (bool) -> string
+std.json.i32_value/u32_value/i64_value/u64_value/f64_value
+std.json.field_string/field_bool/field_i32/field_u32/field_i64/field_u64/field_f64/field_null
+std.json.array0/array1/array2/array3
+std.json.object0/object1/object2/object3
+```
+
+`quote_string` is backed by a compiler-known runtime helper so JSON string
+escaping is deterministic even before Slovo has source-visible byte or
+character iteration. It returns a complete compact JSON string literal,
+including surrounding quotes. The source helpers compose already-encoded JSON
+fragments with compact comma/colon separators.
+
+This release is not a complete JSON or serialization contract. 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, stable runtime helper symbols,
+and stable standard-library API guarantees remain deferred.
+
 ## 4.5 v2.0.0-beta.1 Experimental Integration Readiness
 
 Status: current experimental Slovo-side release contract, released 2026-05-17.

docs/language/STANDARD_RUNTIME.md

@@ -27,6 +27,11 @@ result-returning, and loopback-only; they do not define DNS, TLS, UDP, async
 IO, non-loopback binding, HTTP frameworks, stable socket ABI/layout, or rich
 platform error values.
 
+The `1.0.0-beta.7` serialization/data-interchange foundation release adds
+`std.json.quote_string` behind the `std.json` source facade. It provides
+deterministic compact JSON string quoting before source-level string scanning,
+slicing, maps, or recursive JSON values are available.
+
 The exp-era catalog is closed to names promoted through exp-101. exp-29,
 exp-30, exp-32, exp-33, and exp-35 through exp-93 add no new standard-runtime
 operation names. exp-32/exp-39/exp-56/exp-57 `std/math.slo` helpers,
@@ -71,6 +76,7 @@ source-level result helper names are the `std.result.*` names cataloged below.
 | `std.num.f64_to_i64_result` | `(f64) -> (result i64 i32)` | exp-31 | `examples/supported/f64-to-i64-result.slo` | Returns `ok value` only when the `f64` input is finite, exactly integral, and in the signed `i64` range; returns `err 1` for non-finite, fractional, or out-of-range input without trapping. Conservative fixture values avoid pinning every `f64`/`i64` edge. | Uses existing standard-runtime usage recording if present; no schema change. | Unchecked casts, unchecked f64-to-i64, cast syntax, generic `cast_checked`, f32, unsigned/narrower integer families, mixed numeric arithmetic, broad math, stable helper ABI/layout/ownership. |
 | `std.string.len` | `(string) -> i32` | v1.5 | `examples/supported/standard-runtime.slo` | Returns the existing decoded byte-count length used by legacy `string_len`. | Uses existing standard-runtime usage recording if present; no schema change. | Unicode scalar/grapheme length, slicing, indexing, stable string ABI/layout. |
 | `std.string.concat` | `(string, string) -> string` | exp-1 | `examples/supported/owned-string-concat.slo` | Returns an immutable runtime-owned string; allocation failure traps as `slovo runtime error: string allocation failed`. | Uses existing standard-runtime usage recording if present; no concat-specific schema field. | Mutable strings, string containers, user-visible allocation/deallocation, stable string ABI/layout. |
+| `std.json.quote_string` | `(string) -> string` | `1.0.0-beta.7` | `examples/projects/std-layout-local-json` | Returns a compact JSON string literal for the input text, including surrounding quotes; it escapes quote, backslash, newline, tab, carriage return, backspace, form feed, and other control bytes as JSON escapes. Allocation failure traps as `slovo runtime error: string allocation failed`. | Uses existing standard-runtime usage recording if present; no schema change. | JSON parsing, recursive JSON values, maps/sets, streaming encoders, schema validation, Unicode normalization, embedded NUL support in the current null-terminated string ABI, stable helper ABI/layout/ownership. |
 | `std.vec.i32.empty` | `() -> (vec i32)` | exp-2 | `examples/supported/vec-i32.slo` | Returns an empty immutable runtime-owned `(vec i32)`. | Uses existing standard-runtime usage recording if present; no vector-specific schema field. | Generic vectors, element families beyond `i32`, `i64`, and `string`, vector mutation, stable vector ABI/layout. |
 | `std.vec.i32.append` | `((vec i32), i32) -> (vec i32)` | exp-2 | `examples/supported/vec-i32.slo` | Returns a new immutable vector containing the input elements and appended value; allocation failure traps with the exp-2 vector allocation message. | Uses existing standard-runtime usage recording if present; no vector-specific schema field. | Mutation, `push`, capacity APIs, user deallocation, stable vector ABI/layout. |
 | `std.vec.i32.len` | `((vec i32)) -> i32` | exp-2 | `examples/supported/vec-i32.slo` | Returns vector length as `i32`. | Uses existing standard-runtime usage recording if present; no vector-specific schema field. | Generic length APIs and stable vector ABI/layout. |

docs/language/STDLIB_API.md

@@ -6,15 +6,15 @@ Do not edit this file by hand.
 ## Stability Tiers
 
 - `beta-supported`: exported from `lib/std` and covered by source-search, promotion, or facade gates in the current beta line.
-- `experimental`: not used for exported `lib/std` helpers in `1.0.0-beta.6`; future releases may mark new helpers this way before they graduate.
+- `experimental`: not used for exported `lib/std` helpers in `1.0.0-beta.7`; future releases may mark new helpers this way before they graduate.
 - `internal`: helper names that are not exported from their module; they are intentionally omitted from this catalog.
 
 The catalog is a beta compatibility aid, not a stable `1.0.0` API freeze.
 
 ## Summary
 
-- Modules: 18
+- Modules: 19
-- Exported helpers: 548
+- Exported helpers: 572
 - Default tier: `beta-supported`
 
 ## Modules
@@ -186,6 +186,37 @@ The catalog is a beta compatibility aid, not a stable `1.0.0` API freeze.
 - `read_stdin_bool_or_false`
 - `read_stdin_bool_or`
 
+### std.json
+
+- Path: `lib/std/json.slo`
+- Tier: `beta-supported`
+- Exported helpers: 24
+
+- `quote_string`
+- `null_value`
+- `bool_value`
+- `i32_value`
+- `u32_value`
+- `i64_value`
+- `u64_value`
+- `f64_value`
+- `field_string`
+- `field_bool`
+- `field_i32`
+- `field_u32`
+- `field_i64`
+- `field_u64`
+- `field_f64`
+- `field_null`
+- `array0`
+- `array1`
+- `array2`
+- `array3`
+- `object0`
+- `object1`
+- `object2`
+- `object3`
+
 ### std.math
 
 - Path: `lib/std/math.slo`

docs/language/examples/README.md

@@ -9,7 +9,10 @@ release notes. The current compiler-supported language baseline is
 `1.0.0-beta`; `1.0.0-beta.1` adds tooling/install hardening without changing
 these source-language fixtures. `1.0.0-beta.2` adds beta-scoped
 runtime/resource foundation APIs. `1.0.0-beta.3` adds the generated stdlib API
-catalog and the checked `projects/stdlib-composition/` example. The language
+catalog and the checked `projects/stdlib-composition/` example.
+`1.0.0-beta.7` adds explicit `projects/std-import-json/` and
+`projects/std-layout-local-json/` examples for compact JSON text construction.
+The language
 baseline absorbs the final exp-125 unsigned precursor scope alongside the
 already promoted project/package, stdlib-source, collection, composite-data,
 formatter, and diagnostics surface.

docs/papers/GLAGOL_WHITEPAPER.md

@@ -5,19 +5,20 @@
 Sanjin Gumbarevic<br>
 hermeticum_lab@protonmail.com
 
-Publication release: `1.0.0-beta.6`
+Publication release: `1.0.0-beta.7`
 
 Technical behavior baseline: compiler and language support through
 `1.0.0-beta`; tooling and install workflow through `1.0.0-beta.1`;
 runtime/resource foundation through `1.0.0-beta.2`; standard-library
 stabilization through `1.0.0-beta.3`; language-usability diagnostics through
 `1.0.0-beta.4`; package/workspace discipline through `1.0.0-beta.5`;
-loopback networking foundation through `1.0.0-beta.6`
+loopback networking foundation through `1.0.0-beta.6`;
+serialization/data-interchange foundation through `1.0.0-beta.7`
 
 Date: 2026-05-22
 
 Evidence source: paired local Slovo/Glagol monorepo verification and benchmark
-reruns from a local checkout; beta.6 release-gate verification from the public
+reruns from a local checkout; beta.7 release-gate verification from the public
 monorepo
 
 Maturity: beta
@@ -29,21 +30,23 @@ Slovo. It exists to make the language support boundary inspectable: tokens,
 S-expression tree, AST, typed AST, LLVM IR, hosted native executable, tests,
 diagnostics, and release documents should agree.
 
-The current publication release, `1.0.0-beta.6`, keeps the first real
+The current publication release, `1.0.0-beta.7`, keeps the first real
 general-purpose beta toolchain baseline from `1.0.0-beta` and records the
 first post-beta tooling/install hardening update plus the first
 runtime/resource foundation update plus the first standard-library
 stabilization update plus the first language-usability diagnostics update and
 the first local package/workspace discipline update plus the first loopback
-networking foundation update. The beta baseline includes the completed `u32` /
+networking foundation update plus the first serialization/data-interchange
-`u64` unsigned compiler and stdlib breadth scope, the narrow `std.net`
+foundation update. The beta baseline includes the completed `u32` / `u64`
-loopback TCP runtime family, and the current nine-kernel benchmark suite. This
+unsigned compiler and stdlib breadth scope, the narrow `std.net` loopback TCP
-paper records the current beta implementation surface, the benchmark method and
+runtime family, the narrow `std.json.quote_string` runtime family, and the
-results, the distinction between Glagol and Lisp-family implementations, the
+current ten-scaffold benchmark suite. This paper records the current beta
-beta.1 tooling update, the beta.2 runtime/resource foundation, the beta.3
+implementation surface, the benchmark method and results, the distinction
-standard-library stabilization slice, the beta.4 diagnostics usability slice,
+between Glagol and Lisp-family implementations, the beta.1 tooling update, the
-the beta.5 package discipline slice, the beta.6 networking foundation slice,
+beta.2 runtime/resource foundation, the beta.3 standard-library stabilization
-and the compiler path from beta to stable.
+slice, the beta.4 diagnostics usability slice, the beta.5 package discipline
+slice, the beta.6 networking foundation slice, the beta.7 serialization
+foundation slice, and the compiler path from beta to stable.
 
 ## 1. Compiler Thesis
 
@@ -123,13 +126,15 @@ At the current technical behavior beta baseline, Glagol supports:
   `f64`, `bool`, and `string`
 - compiler-known standard-runtime calls through the promoted catalog plus
   staged source-authored `std/*.slo` gates
+- compact JSON string literal construction through `std.json.quote_string` and
+  the hosted `__glagol_json_quote_string` runtime helper
 - scalar C FFI imports
 - benchmark scaffolds for Slovo, C, Rust, Python, Clojure, and Common
   Lisp/SBCL, with `cold-process` and `hot-loop` timing modes
 
-The current release, `1.0.0-beta.6`, is a beta networking foundation update on
+The current release, `1.0.0-beta.7`, is a beta serialization/data-interchange
-the first release line that may honestly use beta maturity language for this
+foundation update on the first release line that may honestly use beta maturity
-toolchain.
+language for this toolchain.
 
 ## 4. Diagnostics And Support Discipline
 
@@ -218,6 +223,8 @@ Benchmark kernels:
   accumulation
 - `vec-string-eq-loop`: runtime-owned string vector indexing plus exact string
   equality reduced to an `i32` checksum
+- `json-quote-loop`: compact JSON string quoting plus quoted-length checksum
+  accumulation
 
 Comparison boundaries:
 
@@ -250,6 +257,10 @@ Comparison boundaries:
 - `vec-string-eq-loop` keeps the same five-word ASCII corpus and
   runtime-supplied target as `string-eq-loop`, but routes selection through
   the promoted runtime-owned `(vec string)` lane instead of fixed arrays.
+- `json-quote-loop` keeps one runtime-supplied ASCII string containing a quote
+  and a backslash and measures compact JSON string quoting plus quoted-length
+  checksum accumulation. It does not compare JSON parsing, maps, recursive JSON
+  values, schema validation, or streaming encoders.
 - Because Rust is timed at `opt-level=3` while Slovo and C are timed through
   `clang -O2`, the suite is a useful local regression/comparison harness, not a
   strict same-flags compiler shootout.
@@ -266,6 +277,7 @@ python3 benchmarks/array-struct-field-loop/run.py --mode hot-loop --repeats 5 --
 python3 benchmarks/enum-struct-payload-loop/run.py --mode hot-loop --repeats 5 --warmups 1 --glagol compiler/target/debug/glagol
 python3 benchmarks/vec-i32-index-loop/run.py --mode hot-loop --repeats 5 --warmups 1 --glagol compiler/target/debug/glagol
 python3 benchmarks/vec-string-eq-loop/run.py --mode hot-loop --repeats 5 --warmups 1 --glagol compiler/target/debug/glagol
+python3 benchmarks/json-quote-loop/run.py --mode hot-loop --repeats 5 --warmups 1 --glagol compiler/target/debug/glagol
 ```
 
 Cold-process commands:
@@ -280,6 +292,7 @@ python3 benchmarks/array-struct-field-loop/run.py --mode cold-process --repeats
 python3 benchmarks/enum-struct-payload-loop/run.py --mode cold-process --repeats 3 --warmups 1 --glagol compiler/target/debug/glagol
 python3 benchmarks/vec-i32-index-loop/run.py --mode cold-process --repeats 3 --warmups 1 --glagol compiler/target/debug/glagol
 python3 benchmarks/vec-string-eq-loop/run.py --mode cold-process --repeats 3 --warmups 1 --glagol compiler/target/debug/glagol
+python3 benchmarks/json-quote-loop/run.py --mode cold-process --repeats 3 --warmups 1 --glagol compiler/target/debug/glagol
 ```
 
 ## 7. Benchmark Results
@@ -289,8 +302,11 @@ baseline. `1.0.0-beta.1` changes tooling and install workflow, and
 `1.0.0-beta.2` adds runtime/resource APIs, `1.0.0-beta.3` adds
 standard-library catalog and composition coverage, `1.0.0-beta.4` improves
 diagnostics, `1.0.0-beta.5` tightens package/workspace discipline, and
-`1.0.0-beta.6` adds a narrow loopback networking foundation. None of these
+`1.0.0-beta.6` adds a narrow loopback networking foundation, and
-post-beta slices claims changed benchmark performance.
+`1.0.0-beta.7` adds a narrow JSON construction foundation. None of these
+post-beta slices claims changed benchmark performance. The beta.7
+`json-quote-loop` scaffold is present for local follow-up timing and is not
+part of the exp-123 nine-row result table below.
 
 The exp-123 publication baseline widened the paired same-machine result set
 from seven rows to nine by adding two owned-vector kernels:
@@ -378,14 +394,15 @@ coverage and compatibility:
 - package behavior becoming stable before dependency, manifest, and versioning
   rules are precise
 
-## 9. Path Beyond `1.0.0-beta.6`
+## 9. Path Beyond `1.0.0-beta.7`
 
 Glagol now implements the first real beta Slovo contract, the first
 post-beta tooling/install hardening release, the first runtime/resource
 foundation release, the first standard-library stabilization release, and the
-first diagnostics usability release, and the first package/workspace
+first diagnostics usability release, the first package/workspace discipline
-discipline release, and the first loopback networking foundation release. The
+release, the first loopback networking foundation release, and the first
-remaining path is from beta to stable.
+serialization/data-interchange foundation release. The remaining path is from
+beta to stable.
 
 Recommended compiler sequence:
 

docs/papers/SLOVO_WHITEPAPER.md

@@ -5,19 +5,20 @@
 Sanjin Gumbarevic<br>
 hermeticum_lab@protonmail.com
 
-Publication release: `1.0.0-beta.6`
+Publication release: `1.0.0-beta.7`
 
 Technical behavior baseline: language surface through `1.0.0-beta`; tooling
 and install workflow through `1.0.0-beta.1`; runtime/resource foundation through
 `1.0.0-beta.2`; standard-library stabilization through `1.0.0-beta.3`;
 language-usability diagnostics through `1.0.0-beta.4`; package/workspace
 discipline through `1.0.0-beta.5`; loopback networking foundation through
-`1.0.0-beta.6`
+`1.0.0-beta.6`; serialization/data-interchange foundation through
+`1.0.0-beta.7`
 
 Date: 2026-05-22
 
 Evidence source: paired local Slovo/Glagol monorepo verification and benchmark
-reruns from a local checkout; beta.6 release-gate verification from the public
+reruns from a local checkout; beta.7 release-gate verification from the public
 monorepo
 
 Maturity: beta
@@ -32,28 +33,31 @@ explicit types, explicit failure through `option` and `result`, lexical
 `unsafe`, and native compilation through the Glagol compiler to LLVM IR and
 hosted executables.
 
-The current publication release, `1.0.0-beta.6`, keeps the first real
+The current publication release, `1.0.0-beta.7`, keeps the first real
 general-purpose beta language baseline from `1.0.0-beta` and records the first
 post-beta tooling/install hardening update plus the first runtime/resource
 foundation update, the first standard-library stabilization update, and the
 first language-usability diagnostics update, plus the first local
-package/workspace discipline update, and the first loopback networking
+package/workspace discipline update, the first loopback networking foundation
-foundation update. The beta baseline includes the completed `u32` / `u64`
+update, and the first serialization/data-interchange foundation update. The
+beta baseline includes the completed `u32` / `u64`
 unsigned scope, the staged stdlib breadth that makes ordinary command-line
-programs practical, the current narrow `std.net` loopback TCP surface, and the
+programs practical, the current narrow `std.net` loopback TCP surface, the
-current nine-kernel benchmark suite. This paper records the current beta
+current narrow `std.json` text-construction surface, and the current
+ten-scaffold benchmark suite. This paper records the current beta
 technical state, the difference between Slovo and Lisp-family languages, the
 benchmark methodology, the beta.1 tooling update, the beta.2 runtime/resource
 foundation, the beta.3 standard-library stabilization slice, the beta.4
 diagnostics usability slice, the beta.5 package discipline slice, the beta.6
-networking foundation slice, and the remaining path from beta to stable.
+networking foundation slice, the beta.7 serialization foundation slice, and
+the remaining path from beta to stable.
 
 ## 1. Scope
 
 This document is a technical state paper for the current beta baseline. It
 summarizes the behavior represented by the paired local Slovo and Glagol
 workspaces, with `1.0.0-beta` as the current language-surface baseline and
-`1.0.0-beta.6` as the current publication baseline.
+`1.0.0-beta.7` as the current publication baseline.
 
 The support rule remains strict:
 
@@ -65,7 +69,7 @@ The support rule remains strict:
 - partial parser recognition or speculative examples do not count as support
 
 Historical `exp-*` releases remain experimental alpha maturity. The current
-publication accompanies `1.0.0-beta.6`.
+publication accompanies `1.0.0-beta.7`.
 
 ## 2. Design Thesis
 
@@ -180,6 +184,7 @@ std/cli.slo
 std/env.slo
 std/fs.slo
 std/io.slo
+std/json.slo
 std/math.slo
 std/num.slo
 std/option.slo
@@ -295,6 +300,8 @@ Benchmark kernels:
   accumulation
 - `vec-string-eq-loop`: runtime-owned string vector indexing plus exact string
   equality reduced to an `i32` checksum
+- `json-quote-loop`: compact JSON string quoting plus quoted-length checksum
+  accumulation
 
 Comparison boundaries:
 
@@ -327,6 +334,10 @@ Comparison boundaries:
   `(vec string)` lane only: immutable vector creation, checked vector
   indexing, and exact string equality. It should not widen into regex,
   normalization, locale handling, or concat-heavy allocation experiments.
+- `json-quote-loop` should stay on compact JSON string quoting over a
+  runtime-supplied ASCII string containing a quote and a backslash. It should
+  not widen into parsing, recursive JSON values, maps, schema validation, or
+  streaming encoders.
 - Because Rust is timed at `opt-level=3` while Slovo and C are timed through
   `clang -O2`, the suite is a useful local regression/comparison harness, not
   a strict same-flags compiler shootout.
@@ -343,6 +354,7 @@ python3 benchmarks/array-struct-field-loop/run.py --mode hot-loop --repeats 5 --
 python3 benchmarks/enum-struct-payload-loop/run.py --mode hot-loop --repeats 5 --warmups 1 --glagol compiler/target/debug/glagol
 python3 benchmarks/vec-i32-index-loop/run.py --mode hot-loop --repeats 5 --warmups 1 --glagol compiler/target/debug/glagol
 python3 benchmarks/vec-string-eq-loop/run.py --mode hot-loop --repeats 5 --warmups 1 --glagol compiler/target/debug/glagol
+python3 benchmarks/json-quote-loop/run.py --mode hot-loop --repeats 5 --warmups 1 --glagol compiler/target/debug/glagol
 ```
 
 Cold-process commands:
@@ -357,6 +369,7 @@ python3 benchmarks/array-struct-field-loop/run.py --mode cold-process --repeats
 python3 benchmarks/enum-struct-payload-loop/run.py --mode cold-process --repeats 3 --warmups 1 --glagol compiler/target/debug/glagol
 python3 benchmarks/vec-i32-index-loop/run.py --mode cold-process --repeats 3 --warmups 1 --glagol compiler/target/debug/glagol
 python3 benchmarks/vec-string-eq-loop/run.py --mode cold-process --repeats 3 --warmups 1 --glagol compiler/target/debug/glagol
+python3 benchmarks/json-quote-loop/run.py --mode cold-process --repeats 3 --warmups 1 --glagol compiler/target/debug/glagol
 ```
 
 ## 7. Benchmark Results
@@ -366,8 +379,11 @@ baseline. `1.0.0-beta.1` changes tooling and install workflow, and
 `1.0.0-beta.2` adds runtime/resource APIs, `1.0.0-beta.3` adds
 standard-library catalog and composition coverage, `1.0.0-beta.4` improves
 diagnostics, `1.0.0-beta.5` tightens package/workspace discipline, and
-`1.0.0-beta.6` adds a narrow loopback networking foundation. None of these
+`1.0.0-beta.6` adds a narrow loopback networking foundation, and
-post-beta slices claims changed benchmark performance.
+`1.0.0-beta.7` adds a narrow JSON construction foundation. None of these
+post-beta slices claims changed benchmark performance. The beta.7
+`json-quote-loop` scaffold is present for local follow-up timing and is not
+part of the exp-123 nine-row result table below.
 
 The exp-123 publication baseline widened the paired same-machine result set
 from seven rows to nine by adding two owned-vector kernels:
@@ -488,7 +504,7 @@ Major remaining gaps before `1.0.0`:
 - semantic versioning and deprecation policy
 - a clear separation between stable and experimental features
 
-## 10. Path Beyond `1.0.0-beta.6`
+## 10. Path Beyond `1.0.0-beta.7`
 
 The beta threshold is now real. The next work should treat `1.0.0-beta` as
 the language compatibility-governed baseline, `1.0.0-beta.1` as the first
@@ -496,7 +512,8 @@ tooling/install hardening point, `1.0.0-beta.2` as the first runtime/resource
 foundation point, and `1.0.0-beta.3` as the first standard-library
 stabilization point, and `1.0.0-beta.4` as the first diagnostics usability
 point, and `1.0.0-beta.5` as the first package/workspace discipline point,
-and `1.0.0-beta.6` as the first loopback networking foundation point,
+and `1.0.0-beta.6` as the first loopback networking foundation point, and
+`1.0.0-beta.7` as the first serialization/data-interchange foundation point,
 then move deliberately toward stable general-purpose status.
 
 Recommended sequence:

examples/projects/std-import-json/slovo.toml

@@ -0,0 +1,4 @@
+[project]
+name = "std-import-json"
+source_root = "src"
+entry = "main"

examples/projects/std-import-json/src/main.slo

@@ -0,0 +1,92 @@
+(module main)
+
+(import std.json (quote_string null_value bool_value i32_value u32_value i64_value u64_value f64_value field_string field_bool field_i32 field_u32 field_i64 field_u64 field_f64 field_null array0 array1 array2 array3 object0 object1 object2 object3))
+
+(fn imported_json_quote_escapes () -> bool
+  (if (= (quote_string "slovo") "\"slovo\"")
+    (if (= (quote_string "slo\"vo") "\"slo\\\"vo\"")
+      (if (= (quote_string "slo\\vo") "\"slo\\\\vo\"")
+        (= (quote_string "line\nnext") "\"line\\nnext\"")
+        false)
+      false)
+    false))
+
+(fn imported_json_scalar_values () -> bool
+  (if (= (null_value) "null")
+    (if (= (bool_value true) "true")
+      (if (= (bool_value false) "false")
+        (if (= (i32_value -7) "-7")
+          (if (= (u32_value 7u32) "7")
+            (if (= (i64_value 8i64) "8")
+              (if (= (u64_value 9u64) "9")
+                (= (f64_value 1.5) "1.5")
+                false)
+              false)
+            false)
+          false)
+        false)
+      false)
+    false))
+
+(fn imported_json_fields () -> bool
+  (if (= (field_string "name" "slo\"vo") "\"name\":\"slo\\\"vo\"")
+    (if (= (field_bool "ok" true) "\"ok\":true")
+      (if (= (field_i32 "count" 3) "\"count\":3")
+        (if (= (field_u32 "u32" 4u32) "\"u32\":4")
+          (if (= (field_i64 "i64" 5i64) "\"i64\":5")
+            (if (= (field_u64 "u64" 6u64) "\"u64\":6")
+              (if (= (field_f64 "ratio" 2.5) "\"ratio\":2.5")
+                (= (field_null "none") "\"none\":null")
+                false)
+              false)
+            false)
+          false)
+        false)
+      false)
+    false))
+
+(fn imported_json_arrays_objects () -> bool
+  (if (= (array0) "[]")
+    (if (= (array1 (quote_string "a")) "[\"a\"]")
+      (if (= (array2 (quote_string "a") (i32_value 7)) "[\"a\",7]")
+        (if (= (array3 (quote_string "a") (i32_value 7) (bool_value true)) "[\"a\",7,true]")
+          (if (= (object0) "{}")
+            (if (= (object1 (field_string "name" "slovo")) "{\"name\":\"slovo\"}")
+              (if (= (object2 (field_string "name" "slovo") (field_i32 "count" 3)) "{\"name\":\"slovo\",\"count\":3}")
+                (= (object3 (field_string "name" "slovo") (field_i32 "count" 3) (field_bool "ok" true)) "{\"name\":\"slovo\",\"count\":3,\"ok\":true}")
+                false)
+              false)
+            false)
+          false)
+        false)
+      false)
+    false))
+
+(fn imported_json_all () -> bool
+  (if (imported_json_quote_escapes)
+    (if (imported_json_scalar_values)
+      (if (imported_json_fields)
+        (imported_json_arrays_objects)
+        false)
+      false)
+    false))
+
+(fn main () -> i32
+  (if (imported_json_all)
+    42
+    1))
+
+(test "explicit std json quote escapes facade"
+  (imported_json_quote_escapes))
+
+(test "explicit std json scalar values facade"
+  (imported_json_scalar_values))
+
+(test "explicit std json fields facade"
+  (imported_json_fields))
+
+(test "explicit std json arrays objects facade"
+  (imported_json_arrays_objects))
+
+(test "explicit std json facade all"
+  (= (main) 42))

examples/projects/std-layout-local-json/slovo.toml

@@ -0,0 +1,4 @@
+[project]
+name = "std-layout-local-json"
+source_root = "src"
+entry = "main"

examples/projects/std-layout-local-json/src/json.slo

@@ -0,0 +1,78 @@
+(module json (export quote_string null_value bool_value i32_value u32_value i64_value u64_value f64_value field_string field_bool field_i32 field_u32 field_i64 field_u64 field_f64 field_null array0 array1 array2 array3 object0 object1 object2 object3))
+
+(fn quote_string ((value string)) -> string
+  (std.json.quote_string value))
+
+(fn null_value () -> string
+  "null")
+
+(fn bool_value ((value bool)) -> string
+  (if value
+    "true"
+    "false"))
+
+(fn i32_value ((value i32)) -> string
+  (std.num.i32_to_string value))
+
+(fn u32_value ((value u32)) -> string
+  (std.num.u32_to_string value))
+
+(fn i64_value ((value i64)) -> string
+  (std.num.i64_to_string value))
+
+(fn u64_value ((value u64)) -> string
+  (std.num.u64_to_string value))
+
+(fn f64_value ((value f64)) -> string
+  (std.num.f64_to_string value))
+
+(fn field_fragment ((name string) (encoded_value string)) -> string
+  (std.string.concat (std.string.concat (quote_string name) ":") encoded_value))
+
+(fn field_string ((name string) (value string)) -> string
+  (field_fragment name (quote_string value)))
+
+(fn field_bool ((name string) (value bool)) -> string
+  (field_fragment name (bool_value value)))
+
+(fn field_i32 ((name string) (value i32)) -> string
+  (field_fragment name (i32_value value)))
+
+(fn field_u32 ((name string) (value u32)) -> string
+  (field_fragment name (u32_value value)))
+
+(fn field_i64 ((name string) (value i64)) -> string
+  (field_fragment name (i64_value value)))
+
+(fn field_u64 ((name string) (value u64)) -> string
+  (field_fragment name (u64_value value)))
+
+(fn field_f64 ((name string) (value f64)) -> string
+  (field_fragment name (f64_value value)))
+
+(fn field_null ((name string)) -> string
+  (field_fragment name (null_value)))
+
+(fn array0 () -> string
+  "[]")
+
+(fn array1 ((first string)) -> string
+  (std.string.concat (std.string.concat "[" first) "]"))
+
+(fn array2 ((first string) (second string)) -> string
+  (std.string.concat (std.string.concat (std.string.concat (std.string.concat "[" first) ",") second) "]"))
+
+(fn array3 ((first string) (second string) (third string)) -> string
+  (std.string.concat (std.string.concat (std.string.concat (std.string.concat (std.string.concat (std.string.concat "[" first) ",") second) ",") third) "]"))
+
+(fn object0 () -> string
+  "{}")
+
+(fn object1 ((first string)) -> string
+  (std.string.concat (std.string.concat "{" first) "}"))
+
+(fn object2 ((first string) (second string)) -> string
+  (std.string.concat (std.string.concat (std.string.concat (std.string.concat "{" first) ",") second) "}"))
+
+(fn object3 ((first string) (second string) (third string)) -> string
+  (std.string.concat (std.string.concat (std.string.concat (std.string.concat (std.string.concat (std.string.concat "{" first) ",") second) ",") third) "}"))

examples/projects/std-layout-local-json/src/main.slo

@@ -0,0 +1,92 @@
+(module main)
+
+(import json (quote_string null_value bool_value i32_value u32_value i64_value u64_value f64_value field_string field_bool field_i32 field_u32 field_i64 field_u64 field_f64 field_null array0 array1 array2 array3 object0 object1 object2 object3))
+
+(fn imported_json_quote_escapes () -> bool
+  (if (= (quote_string "slovo") "\"slovo\"")
+    (if (= (quote_string "slo\"vo") "\"slo\\\"vo\"")
+      (if (= (quote_string "slo\\vo") "\"slo\\\\vo\"")
+        (= (quote_string "line\nnext") "\"line\\nnext\"")
+        false)
+      false)
+    false))
+
+(fn imported_json_scalar_values () -> bool
+  (if (= (null_value) "null")
+    (if (= (bool_value true) "true")
+      (if (= (bool_value false) "false")
+        (if (= (i32_value -7) "-7")
+          (if (= (u32_value 7u32) "7")
+            (if (= (i64_value 8i64) "8")
+              (if (= (u64_value 9u64) "9")
+                (= (f64_value 1.5) "1.5")
+                false)
+              false)
+            false)
+          false)
+        false)
+      false)
+    false))
+
+(fn imported_json_fields () -> bool
+  (if (= (field_string "name" "slo\"vo") "\"name\":\"slo\\\"vo\"")
+    (if (= (field_bool "ok" true) "\"ok\":true")
+      (if (= (field_i32 "count" 3) "\"count\":3")
+        (if (= (field_u32 "u32" 4u32) "\"u32\":4")
+          (if (= (field_i64 "i64" 5i64) "\"i64\":5")
+            (if (= (field_u64 "u64" 6u64) "\"u64\":6")
+              (if (= (field_f64 "ratio" 2.5) "\"ratio\":2.5")
+                (= (field_null "none") "\"none\":null")
+                false)
+              false)
+            false)
+          false)
+        false)
+      false)
+    false))
+
+(fn imported_json_arrays_objects () -> bool
+  (if (= (array0) "[]")
+    (if (= (array1 (quote_string "a")) "[\"a\"]")
+      (if (= (array2 (quote_string "a") (i32_value 7)) "[\"a\",7]")
+        (if (= (array3 (quote_string "a") (i32_value 7) (bool_value true)) "[\"a\",7,true]")
+          (if (= (object0) "{}")
+            (if (= (object1 (field_string "name" "slovo")) "{\"name\":\"slovo\"}")
+              (if (= (object2 (field_string "name" "slovo") (field_i32 "count" 3)) "{\"name\":\"slovo\",\"count\":3}")
+                (= (object3 (field_string "name" "slovo") (field_i32 "count" 3) (field_bool "ok" true)) "{\"name\":\"slovo\",\"count\":3,\"ok\":true}")
+                false)
+              false)
+            false)
+          false)
+        false)
+      false)
+    false))
+
+(fn imported_json_all () -> bool
+  (if (imported_json_quote_escapes)
+    (if (imported_json_scalar_values)
+      (if (imported_json_fields)
+        (imported_json_arrays_objects)
+        false)
+      false)
+    false))
+
+(fn main () -> i32
+  (if (imported_json_all)
+    42
+    1))
+
+(test "explicit local json quote escapes facade"
+  (imported_json_quote_escapes))
+
+(test "explicit local json scalar values facade"
+  (imported_json_scalar_values))
+
+(test "explicit local json fields facade"
+  (imported_json_fields))
+
+(test "explicit local json arrays objects facade"
+  (imported_json_arrays_objects))
+
+(test "explicit local json facade all"
+  (= (main) 42))

lib/std/README.md

@@ -33,7 +33,9 @@ through released `exp-108`, including the current concrete
 `std/vec_string.slo`, `std/vec_f64.slo`, and `std/vec_bool.slo`
 prefix/suffix helper scopes; `1.0.0-beta.6` networking foundation work releases
 `std/net.slo` as an experimental loopback TCP facade over matching
-compiler-known runtime calls.
+compiler-known runtime calls; `1.0.0-beta.7` serialization work releases
+`std/json.slo` as an experimental JSON text-construction facade over
+`std.json.quote_string` and existing string/number helpers.
 
 This directory is the source home for staged standard library modules and
 examples. exp-44 lets project-mode source explicitly import `std/math.slo` as
@@ -92,6 +94,11 @@ loopback TCP facade over `std.net.tcp_connect_loopback_result`,
 `std.net.tcp_write_text_result`, and `std.net.tcp_close_result`, while keeping
 socket handles beta-scoped opaque `i32` values and leaving DNS, TLS, async,
 UDP, non-loopback binding, and stable ABI/layout deferred;
+`1.0.0-beta.7` releases `std/json.slo` as an experimental compact JSON
+text-construction facade over `std.json.quote_string`, `std.string.concat`,
+and the current `std.num.*_to_string` helpers, while leaving JSON parsing,
+recursive JSON values, maps/sets, streaming encoders, schema validation,
+Unicode normalization, and stable text encoding policy deferred;
 exp-76 extends project-mode source search to `std/vec_i32.slo`, a concrete
 source-authored collection facade over the current promoted `std.vec.i32`
 runtime family; exp-77 extends that facade with concrete option-returning
@@ -136,13 +143,13 @@ For exp-44, exp-45, exp-47, exp-48, exp-49, exp-52, exp-53, exp-76, exp-94,
 exp-96, exp-97, exp-98, exp-99, exp-103, exp-104, exp-105, exp-107, and
 exp-108, `std/math.slo`, `std/result.slo`,
 `std/option.slo`, `std/time.slo`, `std/random.slo`, `std/env.slo`,
-`std/fs.slo`, `std/net.slo`, `std/string.slo`, `std/num.slo`,
+`std/fs.slo`, `std/net.slo`, `std/json.slo`, `std/string.slo`, `std/num.slo`,
 `std/io.slo`, `std/process.slo`, `std/cli.slo`, `std/vec_i32.slo`,
 `std/vec_f64.slo`, `std/vec_i64.slo`, and `std/vec_string.slo` carry explicit
 export lists.
 Glagol may address them externally as `std.math`, `std.result`,
 `std.option`, `std.time`, `std.random`, `std.env`, `std.fs`, `std.string`,
-`std.net`, `std.num`, `std.io`, `std.process`, `std.cli`, `std.vec_i32`,
+`std.net`, `std.json`, `std.num`, `std.io`, `std.process`, `std.cli`, `std.vec_i32`,
 `std.vec_f64`, `std.vec_bool`, `std.vec_i64`, and `std.vec_string`.
 The file layout is the contract:
 
@@ -164,6 +171,7 @@ The file layout is the contract:
 - `std/env.slo`
 - `std/fs.slo`
 - `std/net.slo`
+- `std/json.slo`
 
 This follows a Zig-like standard-library facade discipline in a Slovo-sized
 form: flat `std/*.slo` facade files are the staged source surface now, and a
@@ -278,6 +286,12 @@ close result calls and adds only `tcp_write_text_ok` and `tcp_close_ok` source
 helpers. It is not a general networking module: DNS, TLS, async IO, UDP,
 non-loopback binding, socket options, rich host errors, and stable handle ABI
 remain deferred.
+`std/json.slo` is the beta.7 serialization/data-interchange source facade. It
+wraps `std.json.quote_string` and composes compact JSON scalar, field, small
+array, and small object text from existing string and number helpers. It is
+not a JSON parser and does not define recursive JSON values, maps/sets,
+streaming encoders, schema validation, Unicode normalization, or stable text
+encoding policy beyond the current runtime string ABI.
 `std/process.slo` includes the exp-52 narrow source wrappers over already
 released process argument runtime calls and a source-authored `has_arg`
 predicate. exp-61 adds `arg_or` and `arg_or_empty` as ordinary source

lib/std/json.slo

@@ -0,0 +1,78 @@
+(module json (export quote_string null_value bool_value i32_value u32_value i64_value u64_value f64_value field_string field_bool field_i32 field_u32 field_i64 field_u64 field_f64 field_null array0 array1 array2 array3 object0 object1 object2 object3))
+
+(fn quote_string ((value string)) -> string
+  (std.json.quote_string value))
+
+(fn null_value () -> string
+  "null")
+
+(fn bool_value ((value bool)) -> string
+  (if value
+    "true"
+    "false"))
+
+(fn i32_value ((value i32)) -> string
+  (std.num.i32_to_string value))
+
+(fn u32_value ((value u32)) -> string
+  (std.num.u32_to_string value))
+
+(fn i64_value ((value i64)) -> string
+  (std.num.i64_to_string value))
+
+(fn u64_value ((value u64)) -> string
+  (std.num.u64_to_string value))
+
+(fn f64_value ((value f64)) -> string
+  (std.num.f64_to_string value))
+
+(fn field_fragment ((name string) (encoded_value string)) -> string
+  (std.string.concat (std.string.concat (quote_string name) ":") encoded_value))
+
+(fn field_string ((name string) (value string)) -> string
+  (field_fragment name (quote_string value)))
+
+(fn field_bool ((name string) (value bool)) -> string
+  (field_fragment name (bool_value value)))
+
+(fn field_i32 ((name string) (value i32)) -> string
+  (field_fragment name (i32_value value)))
+
+(fn field_u32 ((name string) (value u32)) -> string
+  (field_fragment name (u32_value value)))
+
+(fn field_i64 ((name string) (value i64)) -> string
+  (field_fragment name (i64_value value)))
+
+(fn field_u64 ((name string) (value u64)) -> string
+  (field_fragment name (u64_value value)))
+
+(fn field_f64 ((name string) (value f64)) -> string
+  (field_fragment name (f64_value value)))
+
+(fn field_null ((name string)) -> string
+  (field_fragment name (null_value)))
+
+(fn array0 () -> string
+  "[]")
+
+(fn array1 ((first string)) -> string
+  (std.string.concat (std.string.concat "[" first) "]"))
+
+(fn array2 ((first string) (second string)) -> string
+  (std.string.concat (std.string.concat (std.string.concat (std.string.concat "[" first) ",") second) "]"))
+
+(fn array3 ((first string) (second string) (third string)) -> string
+  (std.string.concat (std.string.concat (std.string.concat (std.string.concat (std.string.concat (std.string.concat "[" first) ",") second) ",") third) "]"))
+
+(fn object0 () -> string
+  "{}")
+
+(fn object1 ((first string)) -> string
+  (std.string.concat (std.string.concat "{" first) "}"))
+
+(fn object2 ((first string) (second string)) -> string
+  (std.string.concat (std.string.concat (std.string.concat (std.string.concat "{" first) ",") second) "}"))
+
+(fn object3 ((first string) (second string) (third string)) -> string
+  (std.string.concat (std.string.concat (std.string.concat (std.string.concat (std.string.concat (std.string.concat "{" first) ",") second) ",") third) "}"))

runtime/runtime.c

@@ -726,6 +726,105 @@ char *__glagol_string_concat(const char *left, const char *right) {
     return value;
 }
 
+static char __glagol_json_hex_digit(unsigned char value) {
+    return value < 10u ? (char)('0' + value) : (char)('A' + (value - 10u));
+}
+
+static void __glagol_json_add_size(size_t *total, size_t amount) {
+    if (*total > SIZE_MAX - amount) {
+        __glagol_allocation_trap();
+    }
+    *total += amount;
+}
+
+char *__glagol_json_quote_string(const char *text) {
+    if (text == NULL) {
+        text = "";
+    }
+
+    size_t escaped_len = 2u;
+    const unsigned char *cursor = (const unsigned char *)text;
+    while (*cursor != '\0') {
+        switch (*cursor) {
+            case '"':
+            case '\\':
+            case '\b':
+            case '\f':
+            case '\n':
+            case '\r':
+            case '\t':
+                __glagol_json_add_size(&escaped_len, 2u);
+                break;
+            default:
+                __glagol_json_add_size(&escaped_len, *cursor < 0x20u ? 6u : 1u);
+                break;
+        }
+        cursor++;
+    }
+
+    if (escaped_len == SIZE_MAX) {
+        __glagol_allocation_trap();
+    }
+
+    char *value = malloc(escaped_len + 1u);
+    if (value == NULL) {
+        __glagol_allocation_trap();
+    }
+
+    char *out = value;
+    *out++ = '"';
+    cursor = (const unsigned char *)text;
+    while (*cursor != '\0') {
+        unsigned char ch = *cursor;
+        switch (ch) {
+            case '"':
+                *out++ = '\\';
+                *out++ = '"';
+                break;
+            case '\\':
+                *out++ = '\\';
+                *out++ = '\\';
+                break;
+            case '\b':
+                *out++ = '\\';
+                *out++ = 'b';
+                break;
+            case '\f':
+                *out++ = '\\';
+                *out++ = 'f';
+                break;
+            case '\n':
+                *out++ = '\\';
+                *out++ = 'n';
+                break;
+            case '\r':
+                *out++ = '\\';
+                *out++ = 'r';
+                break;
+            case '\t':
+                *out++ = '\\';
+                *out++ = 't';
+                break;
+            default:
+                if (ch < 0x20u) {
+                    *out++ = '\\';
+                    *out++ = 'u';
+                    *out++ = '0';
+                    *out++ = '0';
+                    *out++ = __glagol_json_hex_digit((unsigned char)(ch >> 4u));
+                    *out++ = __glagol_json_hex_digit((unsigned char)(ch & 0x0Fu));
+                } else {
+                    *out++ = (char)ch;
+                }
+                break;
+        }
+        cursor++;
+    }
+    *out++ = '"';
+    *out = '\0';
+    return value;
+}
+
 static char *__glagol_num_u64_to_string_impl(uint64_t magnitude, bool negative) {
     char reversed[20];
     size_t digit_count = 0;

tests/std-abi-layout-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 52)
     (range 5 4 5 18)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.abi.layout")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-async-spawn-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 53)
     (range 5 4 5 19)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.async.spawn")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-fs-list-dir-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 53)
     (range 5 4 5 19)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.fs.list_dir")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-fs-read-binary-unsupported-alias.diag

@@ -9,7 +9,7 @@
     (bytes 41 59)
     (range 5 4 5 22)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.fs.read_binary")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-io-prompt-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 41 54)
     (range 5 4 5 17)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.io.prompt")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-io-read-line-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 54)
     (range 5 4 5 20)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.io.read_line")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-io-read-stdin-async-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 61)
     (range 5 4 5 27)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.io.read_stdin_async")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-io-read-stdin-binary-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 62)
     (range 5 4 5 28)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.io.read_stdin_binary")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-io-read-stdin-bytes-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 61)
     (range 5 4 5 27)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.io.read_stdin_bytes")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-io-read-stdin-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 55)
     (range 5 4 5 21)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.io.read_stdin")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-io-stdin-encoding-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 59)
     (range 5 4 5 25)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.io.stdin_encoding")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-io-stdin-lines-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 56)
     (range 5 4 5 22)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.io.stdin_lines")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-io-stdin-stream-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 57)
     (range 5 4 5 23)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.io.stdin_stream")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-net-connect-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 53)
     (range 5 4 5 19)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.net.connect")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-num-cast-checked-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 58)
     (range 5 4 5 24)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.num.cast_checked")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-num-cast-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 50)
     (range 5 4 5 16)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.num.cast")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-num-f64-to-i32-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 56)
     (range 5 4 5 22)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.num.f64_to_i32")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-num-f64-to-i64-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 56)
     (range 5 4 5 22)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.num.f64_to_i64")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-num-i32-to-i64-result-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 63)
     (range 5 4 5 29)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.num.i32_to_i64_result")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-num-i64-to-i32-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 56)
     (range 5 4 5 22)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.num.i64_to_i32")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-num-to-string-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 55)
     (range 5 4 5 21)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.num.to_string")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-package-load-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 54)
     (range 5 4 5 20)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.package.load")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-platform-os-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 53)
     (range 5 4 5 19)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.platform.os")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-random-bytes-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 54)
     (range 5 4 5 20)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.random.bytes")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-random-crypto-i32-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 59)
     (range 5 4 5 25)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.random.crypto_i32")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-random-float-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 54)
     (range 5 4 5 20)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.random.float")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-random-range-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 54)
     (range 5 4 5 20)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.random.range")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-random-seed-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 53)
     (range 5 4 5 19)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.random.seed")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-random-shuffle-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 56)
     (range 5 4 5 22)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.random.shuffle")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-random-string-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 41 58)
     (range 5 4 5 21)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.random.string")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-random-uuid-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 41 56)
     (range 5 4 5 19)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.random.uuid")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-result-map-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 52)
     (range 5 4 5 18)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.result.map")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-from-i64-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 57)
     (range 5 4 5 23)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.from_i64")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-index-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 54)
     (range 5 4 5 20)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.index")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-bool-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 59)
     (range 5 4 5 25)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_bool")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-bytes-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 67)
     (range 5 4 5 33)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_bytes_result")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-f64-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 58)
     (range 5 4 5 24)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_f64")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-generic-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 61)
     (range 5 4 5 27)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_result")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-i32-base-prefix-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 77)
     (range 5 4 5 43)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_i32_base_prefix_result")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-i32-binary-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 72)
     (range 5 4 5 38)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_i32_binary_result")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-i32-code-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 70)
     (range 5 4 5 36)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_i32_code_result")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-i32-error-adt-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 71)
     (range 5 4 5 37)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_i32_error_result")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-i32-hex-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 69)
     (range 5 4 5 35)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_i32_hex_result")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-i32-locale-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 72)
     (range 5 4 5 38)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_i32_locale_result")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-i32-message-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 73)
     (range 5 4 5 39)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_i32_message_result")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-i32-octal-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 71)
     (range 5 4 5 37)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_i32_octal_result")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-i32-plus-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 70)
     (range 5 4 5 36)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_i32_plus_result")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-i32-radix-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 71)
     (range 5 4 5 37)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_i32_radix_result")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-i32-trim-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 70)
     (range 5 4 5 36)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_i32_trim_result")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-i32-underscore-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 76)
     (range 5 4 5 42)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_i32_underscore_result")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-i32-unicode-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 73)
     (range 5 4 5 39)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_i32_unicode_result")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-i32-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 58)
     (range 5 4 5 24)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_i32")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )

tests/std-string-parse-i32-whitespace-unsupported.diag

@@ -9,7 +9,7 @@
     (bytes 38 76)
     (range 5 4 5 42)
   )
-  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
+  (expected "std.io.print_i32, std.io.print_u32, std.io.print_i64, std.io.print_u64, std.io.print_f64, std.io.print_string, std.io.print_bool, std.io.eprint, std.io.read_stdin_result, std.string.len, std.string.concat, std.string.parse_i32_result, std.string.parse_u32_result, std.string.parse_i64_result, std.string.parse_u64_result, std.string.parse_f64_result, std.string.parse_bool_result, std.json.quote_string, std.process.argc, std.process.arg, std.process.arg_result, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, std.fs.write_text_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, std.fs.create_dir_result, std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, std.vec.i32.index, std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, std.vec.i64.index, std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, std.vec.f64.index, std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, std.vec.bool.index, std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, std.time.monotonic_ms, std.time.sleep_ms, std.random.i32, std.num.i32_to_i64, std.num.i32_to_f64, std.num.i64_to_f64, std.num.i64_to_i32_result, std.num.f64_to_i32_result, std.num.f64_to_i64_result, std.num.i32_to_string, std.num.u32_to_string, std.num.i64_to_string, std.num.u64_to_string, std.num.f64_to_string, std.result.is_ok, std.result.is_err, std.result.unwrap_ok, or std.result.unwrap_err")
   (found "std.string.parse_i32_whitespace_result")
   (hint "use a promoted standard-runtime name or a legacy intrinsic alias")
 )