DOCUMENTATION / VERSION 1.11.1

Sura 언어
레퍼런스

문법과 실행 모델부터 CLI, 표준 라이브러리, 플랫폼별 제한, 배포 파일의 검증 근거까지 한 HTML 문서에 정리했습니다. 다른 도구가 읽을 수 있는 구조화 JSON도 같은 문서에 포함합니다.

1.11.1 · 2026-09-02 · UTF-8 · 528 API signatures

문서 개요

이 문서는 Sura Language 1.11.1의 공개 레퍼런스입니다. 문법, 런타임 의미, 명령행, 표준 라이브러리 API, 동시성, AI/CUDA, 미디어, 외부 연동, 패키지 관리, 타깃 상태와 검증 기록을 한 파일에 담습니다.

실행 파이프라인lexer → parser/AST → strict typecheck → register bytecode → register VM. Windows x64는 전체 JIT, Linux x86-64와 ARM64는 배열·문자열·딕셔너리를 VM helper로 처리하는 baseline JIT를 사용합니다.

API 인벤토리runtime module namespace 35개, catalog module 34개, module signature 528개, global builtin name·alias 664개입니다.

검증 기준최종 1.11.1 engine에서 stable suite는 VM 107/107 PASS와 JIT 107/107 PASS를 통과했습니다.

Sura source 확장자는 .sura입니다. 값은 NaN-boxed dynamic Value로 표현하고, register VM과 mark-sweep GC(문자열·배열·딕셔너리·인스턴스는 타입별 free list 풀에서 할당)가 실행하며, 딕셔너리는 삽입 순서를 지키는 compact open-addressing 표(항목은 4부터 두 배씩 커지는 청크에, 인덱스는 2의 거듭제곱 크기의 선형 탐사 표)입니다. 순회와 출력은 삽입 순서를 따르고, 삭제된 항목은 인덱스 재구성 때 압축되며, 문자열 키의 해시는 문자열 객체에 한 번만 계산해 캐시합니다. 할당은 임베딩 API로 컨텍스트가 만들어지기 전까지 런타임 뮤텍스를 잡지 않습니다(명령줄 엔진은 단일 스레드). GC heap은 프로세스 전역입니다.

기본 진단 언어는 영어입니다. 한국어 진단은 --lang ko 또는 SURA_LANG=ko로 선택합니다.

호환성과 지원 등급

공개 호환성 보장은 1.11.1부터 적용합니다. 패치 릴리스의 공개 호환성 파괴는 금지하며, 마이너 릴리스에서 기존 기능을 없애거나 의미를 바꾸려면 최소 1번의 마이너 릴리스 동안 지원 중단 절차를 거칩니다. 1.10 검사는 보관된 실제 런타임과 현재 런타임의 역사 검증 자료이며 1.10 지원을 소급 보장하지 않습니다.

영역	현재 계약
소스	1.11 호환 fixture 3개를 strict check, VM, JIT 또는 fallback, bytecode load에서 검사
역사 검증	1.10.0 공개 ZIP·엔진 해시를 확인하고 1.10 fixture 3개를 이전·현재 VM/JIT fallback에서 실행
바이트코드	형식 3 생성, 형식 2·3 읽기
보호 릴리스 패키지	형식 5 생성, 형식 1·2·3·4·5 읽기
Plugin ABI	1.1.0
Embedding FFI ABI	1.2.0

안정

native Sura syntax and register VM
core values, control flow, functions, classes, and exceptions
file, string, array, dictionary, JSON, and test APIs
surapkg project creation, run, test, and lock file
C FFI and versioned plugin ABI

플랫폼 한정

native JIT on Win64 x86-64 for supported opcodes and functions, plus exception-free straight-line baselines on Linux x86-64 and little-endian Windows/Linux/macOS ARM64 for constants, moves, proven-numeric addition, subtraction, multiplication, unary negation, six comparisons, and division by a proven nonzero divisor
CUDA resident operations on compatible NVIDIA systems
media operations when FFmpeg is installed or explicitly configured
Windows installer and Microsoft Store package for Windows x64

실험

JavaScript and WebAssembly translation targets
Transformer extensions and distributed training
bounded byte-level BPE tokenizer and its version 2 tokenizer file
bounded CPU ONNX opset 7 through 18 graph execution subset
advanced protected-release policies and external registry operations

플랫폼 한정 기능은 요구 조건이 맞지 않을 때 문서화된 VM fallback 또는 명시적인 오류를 사용합니다. 실험 기능은 마이너 버전에서 바뀔 수 있으며, 안정 등급으로 올리기 전에 지원 플랫폼, 실패 동작, 호환 fixture와 CI 검사를 추가합니다. 전체 정책과 검증 명령은 COMPATIBILITY.md에 기록되어 있습니다.

범위와 기여

Sura의 핵심 범위는 native syntax, register bytecode와 VM, core language constructs, practical stdlib, package project workflow, C FFI·Plugin ABI와 실제 구현에서 생성되는 도구 문서입니다. 플랫폼·외부 프로그램 조건이 있는 JIT, CUDA, media, installer와 bridge는 조건부 범위이고 JavaScript·WebAssembly 변환, Transformer 확장과 외부 registry 운영은 실험 범위입니다.

새 public syntax, builtin, module, CLI option과 file format은 처음에는 실험으로 분류합니다. 지원 플랫폼, 실패·fallback test, 실제 문법 예제와 reference, 호환성 영향, 적용 가능한 CI 검사가 모두 있어야 안정 또는 플랫폼 한정 등급으로 올릴 수 있습니다.

문서	용도
`SCOPE.md`	핵심·조건부·실험 범위와 안정 승격 조건
`CONTRIBUTING.md`	실제 Sura 문법, build·test·package 기여 절차
`.github/ISSUE_TEMPLATE/feature_request.yml`	지원 등급, fallback, 호환성과 검증 계획을 요구하는 기능 제안
`.github/ISSUE_TEMPLATE/package_submission.yml`	test·quality·publish dry-run 증거를 요구하는 package 제안

설치와 실행

Windows x64 공개 파일

파일	용도
Microsoft Store	Microsoft 인증 기본 설치; 게시자 SuraTeam, 무료
SuraLanguageSetup-1.11.1.exe	단일 설치 파일
SuraLanguage-1.11.1-windows-x64.zip	설치 kit와 payload 검증
SuraLanguage-VSCode-1.11.1.vsix	VS Code 언어 확장

기본 설치 경로는 Microsoft Store입니다. 직접 다운로드 설치기는 Windows x64, .NET Framework CLR, Windows PowerShell 또는 PowerShell을 사용합니다. 설치된 runtime은 %LOCALAPPDATA%\Programs\Sura\bin에 위치하고 sura와 surapkg 명령을 만듭니다.

직접 다운로드 설치기의 Authenticode 상태는 NotSigned입니다. 설치 대상 실행 파일이 사용 중이면 1.11.1 설치기는 덮어쓰기 전에 중단하고 Sura REPL·터미널·VS Code를 닫으라는 안내와 %LOCALAPPDATA%\Sura\Logs의 로그 경로를 표시합니다.

sura --version
surapkg examples
surapkg example algorithms/word_frequency my_example
surapkg new my_app
cd my_app
surapkg run
surapkg test

소스 checkout 빌드

.\build.bat portable
.\SuraLanguage.exe --version
.\SuraLanguage.exe .\app.sura

실행 기능별 외부 요구사항: 영상 decoding은 FFmpeg를 사용합니다. native HTTP·async HTTP·HTTP 기반 LLM 요청은 curl을 실행합니다. http.serve_routes는 Node.js를 사용하고 http.serve_static은 Node.js를 먼저 사용한 뒤 Python을 사용할 수 있습니다. Python bridge는 Python, JS target과 VS Code 도구 검증은 Node.js, native FFI/plugin/embedding build는 C/C++ toolchain을 사용합니다.

값과 기본 문법

source는 UTF-8이며 UTF-8 BOM도 받습니다. 한 줄 주석은 #와 //를 사용합니다. 문자열은 큰따옴표로 작성하고 \n \r \t \" \\ escape와 {expression} interpolation을 지원합니다.

# comment
// comment
name is "Sura"
count: number is 3
enabled is true
missing is nil
items is [1, 2, 3]
profile is {name: "Ada", level: 7}
print("hello {name}, next={count + 1}")

형태	문법
선언·재대입	`name is value`
타입 표기	`name: type is value`
복합 대입	`+= -= *= /= %=`
field/index 대입	`object.field is value`, `array[index] is value`
optional access	`value?.field`
nil coalescing	`left ?? right`
삼항식	`condition ? then_value : else_value`
source import	`import "./lib.sura"`
stdlib module	`use json`

let, var, const, Python 들여쓰기 block, C/JavaScript 중괄호 statement block은 Sura parser 문법에 포함되지 않습니다.

타입과 연산

Sura 1.11.1의 기본 검사는 strict-by-default 점진적 타입 검사입니다. type annotation이 알려진 지점은 검사하고 builtin·property·index·method 반환의 상당수는 any로 추론합니다.

annotation	의미
`number`	IEEE-754 double
`int / float / double`	`number`와 같은 runtime 숫자 표현의 annotation alias
`string`	UTF-8 문자열
`bool`	`true`, `false`
`nil`	값 없음
`array`	순서 있는 Value 목록
`dict`	문자열 key 기반 Value map
`any`	모든 값과 호환
class name	해당 class instance와 상속 관계

숫자/문자열/불리언/논리/배열/사전/없음/아무 한국어 alias도 지원합니다. type(value)의 runtime 이름에는 number, string, bool, nil, array, dict, tensor, function, instance, object가 포함됩니다. function/object/tensor를 annotation에 쓰면 현재 parser는 class name으로 보존합니다.

모든 annotation은 nil을 허용합니다. named function parameter·return과 class extends 관계는 검사합니다. class method annotation은 parser가 받으며 현재 typechecker가 강제하지 않습니다.

strict type checking이 기본입니다. type error는 본문 실행 전에 중단됩니다. --legacy-types는 source 실행에서 warning 후 진행하며 --compile과 --release에는 적용되지 않습니다.

Truthiness

false	true
`nil, false, 0`	0이 아닌 number
빈 string·array·dict	비어 있지 않은 string·array·dict
	function·instance·tensor와 나머지 object value

연산자

그룹	연산자와 의미
산술	`+ - * / %`; string이 한쪽에 있으면 `+`가 다른 값을 문자열로 변환; array + array는 새 배열로 연결
비교	`== != < <= > >=`; ordering 네 연산은 number operand만 허용
논리	`and or not`; runtime truthiness 사용
포함	`value in collection`
비트	`& \| ^ ~ << >>`
선택	`condition ? a : b`, `left ?? right`

우선순위

아래 표는 낮은 우선순위에서 높은 우선순위 순서입니다. 비교 연산은 괄호 없는 한 식에서 하나만 파싱합니다.

순서	연산자	결합
1	`??`	오른쪽; left가 nil일 때만 right 평가
2	`? :`	오른쪽; 선택된 branch만 평가
3	`or`	왼쪽; short-circuit
4	`and`	왼쪽; short-circuit
5	`not`	prefix
6	`== != < <= > >= in`	비교 하나
7–9	`\| ^ &`	각 단계 왼쪽
10	`<< >>`	왼쪽
11	`+ -`	왼쪽
12	`* / %`	왼쪽
13	`unary - ~`	prefix
14	`call index . ?.`	postfix

연산자 우선순위: 낮음 → 높음

단계	연산자	결합
1	`??`	오른쪽
2	`? :`	오른쪽
3–4	`or`, `and`	왼쪽; short-circuit
5	`not`	prefix
6	`== != < <= > >= in`	괄호 없는 식에서 비교 1회
7–9	`\| ^ &`	각 단계 왼쪽
10	`<< >>`	왼쪽
11	`+ -`	왼쪽
12	`* / %`	왼쪽
13	`unary - ~`	prefix
14	`call index . ?.`	postfix

and/or는 short-circuit하고 선택된 operand 값을 반환합니다. 현재 typechecker의 결과 추론은 bool입니다. array + array는 VM, strict checker, JS target에서 연결 연산으로 처리합니다. WASM target은 정적 배열끼리, 같은 ABI의 동적 배열끼리, 원소 metadata가 증명된 raw 배열과 tagged 동적 배열의 혼합을 연결합니다. WASM의 직접 원소 타입 증거는 배열 연산과 조건식의 AST를 최대 8단계까지만 따라가며, 함수 본문 전체를 추론하지 않습니다. 이 범위를 넘어 원소 metadata가 없는 raw Value와 tagged 동적 배열의 혼합은 아직 nil을 반환합니다.

비트 operand는 유한 정수이고 절댓값이 2^53 - 1 이하여야 합니다. shift count는 0..63입니다. left shift 결과는 safe integer 범위 안에 있어야 하며 right shift는 arithmetic shift로 정의됩니다.

제어 흐름

조건

if score >= 90 then
  print("A")
elif score >= 80 then
  print("B")
else
  print("C")
end

if score > 0 then print("positive") else print("zero")

반복

while ready do
  break
end

repeat 3 do
  continue
end

for n in 1 to 5 step 2 do
  print(n)
end

range for는 정방향·역방향 step과 1 ~ 3 형태를 지원합니다. array, dict, string 순회는 for value in collection과 for key, value in collection 형태를 사용합니다.

match와 when

match status
  when "ready" then
    print("go")
  when _ then
    print("wait")
end

when score do
in 1 ~ 100 then
  print("range")
else then
  print("outside")
end

함수와 스코프

func add(value: number, delta: number is 1) -> number do
  return value + delta
end

double is func(value) do
  return value * 2
end

scale is |value| value * 4
ready is || true

함수 선언, anonymous block function, expression lambda를 함수 값으로 저장할 수 있습니다. 함수는 lexical closure를 만들며 바깥 local을 캡처합니다.

func make_counter() do
  count is 0
  func next() do
    count += 1
    return count
  end
  return next
end

함수 안에서 top-level variable을 명시적으로 갱신할 때 global name을 선언합니다. parameter default는 name is value 또는 name: type is value로 작성합니다.

기본값 표현식은 positional argument가 생략된 호출에서만 왼쪽부터 평가합니다. 명시적으로 전달한 nil은 유지됩니다. 뒤쪽 기본값은 앞쪽 parameter를 참조할 수 있고 method default는 self를 참조할 수 있습니다. named function, anonymous function, lambda와 method가 같은 규칙을 사용합니다.

객체와 컬렉션

class와 상속

class Animal do
  aliases is []
  func init(name) do
    self.name is name
  end
  func speak() do
    return "..."
  end
end

class Dog extends Animal do
  func init(name) do
    super.init(name)
  end
  func speak() do
    return self.name + ": bark"
  end
end

dog is new Dog("Badu")

class field 기본값은 새 instance마다 부모 class에서 자식 class 순서, 각 class의 선언 순서로 평가합니다. array와 dict 결과도 instance별 값이므로 한 instance의 field 변경이 다른 instance의 기본 field를 변경하지 않습니다. 자동 struct constructor의 field 기본값은 해당 argument를 생략한 생성에서 평가하고, 명시한 argument의 기본식은 실행하지 않습니다.

struct와 enum

struct Vec2 do
  x
  y
  func length2() do
    return self.x * self.x + self.y * self.y
  end
end

enum Code do
  OK is 200
  FAIL is 500
end

array는 items[index], dict는 value.key와 value["key"]로 접근합니다. 문자열은 trim/lower/upper/split/contains/starts_with/ends_with/repeat/pad_left/pad_right 등의 method를 제공합니다. array는 len/push/insert/remove/join/contains 등의 method를 제공합니다.

array는 음수 index를 지원하고 범위를 벗어나면 오류를 냅니다. dict의 없는 key는 nil입니다. string index의 단위는 UTF-8 byte이며 범위를 벗어나면 nil입니다. array·dict·function·instance·tensor equality는 identity 비교입니다.

오류와 진단

try
  throw "failed"
catch error
  print(error)
finally do
  print("cleanup")
end

예외 block은 try, catch name, 선택형 finally do, end 순서입니다.

코드	범위
`E100 / E101`	정의되지 않은 변수·함수
`E200 / E201`	대입·operand type, numeric ordering
`E202`	0 나눗셈·나머지, 범위 초과 등 runtime value 오류
`E203 / E204`	인자 개수·인자 type과 safe integer/shift 계약
`E205 / E206`	return type·default parameter type
`E207 / E208`	반복 범위·iterable type
`E209 / E210`	복합 대입·match pattern type
`E300`	runtime 호출 인자 개수
`E500`	runtime 내부 한도·불가능한 opcode

sura --check path는 실행 없이 parse와 typecheck를 수행합니다. parser diagnostics는 줄 경계에서 복구해 한 파일의 후속 syntax error도 보고합니다.

실행기 CLI

아래 목록은 SuraLanguage.exe --help의 1.11.1 출력입니다.

Sura Language Runtime 1.11.1
Usage:
  sura --version             Show the Sura Language version
  sura --jit-info            Show native JIT OS, architecture, ABI, and fallback
  sura --jit-info-json       Show machine-readable JIT target information
  sura <file.sura> [--] [args...]  Run file with script argv
  sura --repl                Interactive REPL
  sura --dump <file.sura>    Show bytecode
  sura --bench <file.sura>   Benchmark
  sura --strict <file.sura>  Explicitly select the default strict type checking
  sura --legacy-types <file.sura>  Legacy mode: report type warnings and continue
  sura --compile <file.sura>  Compile to .sura.bc (no run)
  sura --release <file.sura>  Build a .sura.srp release container
  sura --release-key <key>    Require key for --release package execution
  sura --release-key-file <path> Read release key from a UTF-8 file
  sura --release-license <license> Require license value for release execution
  sura --release-license-file <path> Read release license from a UTF-8 file
  sura --release-id <id>      Store release/customer id in package metadata
  sura --release-expires YYYY-MM-DD  Expire release package after date
  sura --out <path>           Output path for --compile/--release
  sura --profile <file.sura>  Run with type profiling report
  sura --profile-json out.json <file.sura>  Write machine-readable profile report
  sura --gc-stats <file.sura>  Run a final GC and print pause/object statistics
  sura --gc-stats-json out.json <file.sura>  Write machine-readable GC statistics
  sura --trace <file.sura>    Trace VM instructions
  sura --debug <file.sura>    Dump bytecode, trace, and profile
  sura --debug-protocol <file.sura>  Run line-stop debugger protocol
  sura --lang en|ko           Set diagnostic language (default: English; env SURA_LANG)
  sura --test [path]          Discover and run Sura tests
  sura --test-report out.json [path]  Write machine-readable test results
  sura --check [path]         Parse and typecheck without running
  sura --strict-syntax [path] Reject legacy command-style calls; use name(...)
  sura --ast-json [--out out.json] <file.sura>  Emit machine-readable AST JSON
  sura --lint [path]          Run lightweight static lint checks
  sura --format <path>        Format Sura files in place
  sura --format-check <path>  Check Sura formatting without writing
  sura --jit <file.sura>      Enable native JIT (Win64 x64; VM fallback elsewhere)
  sura --load <file.sura.bc> Run precompiled bytecode
  sura --load-release <file.sura.srp> Run a .sura.srp release container
  sura --load-release-key <key> Key for .sura.srp release container
  sura --load-release-key-file <path> Read release key from a UTF-8 file
  sura --load-release-license <license> License for .sura.srp release container
  sura --load-release-license-file <path> Read release license from a UTF-8 file
  SURA_ALLOW_RELEASE_INSPECT=1 allows dump/trace/debug on protected packages
  sura --lsp                 Language Server mode

표준 라이브러리

VM의 runtime module namespace는 35개입니다. surapkg docs와 surapkg info가 signature metadata를 제공하는 module은 34개·528 signature이며, console이 별도 runtime module입니다. global builtin registry에는 case-sensitive 직접 호출 이름과 alias 664개가 있습니다.

surapkg list --json의 package inventory는 39 entry입니다. data/time/web은 각각 json/datetime/http alias로 canonicalize됩니다. game/system source file은 package inventory에 나타나며 VM의 use module namespace에는 포함되지 않습니다.

이름	runtime/source 경로	공개 metadata
`array`	builtin:array	API signature 제공
`async`	builtin:async	API signature 제공
`autograd`	builtin:autograd	API signature 제공
`cli`	builtin:cli	API signature 제공
`crypto`	builtin:crypto	API signature 제공
`data`	stdlib/data.sura	source module entry
`dataset`	builtin:dataset	API signature 제공
`datetime`	builtin:datetime	API signature 제공
`db`	builtin:db	API signature 제공
`dict`	builtin:dict	API signature 제공
`ffi`	builtin:ffi	API signature 제공
`fs`	builtin:fs	API signature 제공
`game`	stdlib/game.sura	source module entry
`graphics3d`	builtin:graphics3d	API signature 제공
`http`	builtin:http	API signature 제공
`json`	builtin:json	API signature 제공
`llm`	builtin:llm	API signature 제공
`log`	builtin:log	API signature 제공
`math`	stdlib/math.sura	API signature 제공
`media`	builtin:media	API signature 제공
`nn`	builtin:nn	API signature 제공
`os`	stdlib/os.sura	API signature 제공
`path`	builtin:path	API signature 제공
`plugin`	builtin:plugin	API signature 제공
`python`	builtin:python	API signature 제공
`rag`	builtin:rag	API signature 제공
`random`	builtin:random	API signature 제공
`regex`	builtin:regex	API signature 제공
`set`	builtin:set	API signature 제공
`stream`	builtin:stream	API signature 제공
`string`	stdlib/string.sura	API signature 제공
`system`	stdlib/system.sura	source module entry
`tensor`	builtin:tensor	API signature 제공
`test`	builtin:test	API signature 제공
`time`	stdlib/time.sura	source module entry
`tokenizer`	builtin:tokenizer	API signature 제공
`tool`	builtin:tool	API signature 제공
`vector`	builtin:vector	API signature 제공
`web`	stdlib/web.sura	source module entry

34개 내장 module API

array — 배열 생성·복사·정렬·검색·집계20 signatures

이름	호출 서명
`len`	`array.len(array)`
`length`	`array.length(array)`
`size`	`array.size(array)`
`slice`	`array.slice(array, start, [end])`
`sort`	`array.sort(array)`
`reverse`	`array.reverse(array)`
`concat`	`array.concat(array, ...)`
`push`	`array.push(array, value, ...)`
`pop`	`array.pop(array)`
`clone`	`array.clone(array)`
`contains`	`array.contains(array, value)`
`index_of`	`array.index_of(array, value)`
`sum`	`array.sum(array)`
`avg`	`array.avg(array)`
`unique`	`array.unique(array)`
`flatten`	`array.flatten(array, [depth])`
`range`	`array.range(end) \| array.range(start, end, [step])`
`chunk`	`array.chunk(array, size)`
`zip`	`array.zip(array, ...)`
`repeat`	`array.repeat(value, count)`

async — bounded worker pool 기반 command·HTTP·timer task와 structured scope27 signatures

이름	호출 서명
`cmd`	`async.cmd(command, [scope_id])`
`ready`	`async.ready(task_id)`
`http_get`	`async.http_get(url, [scope_id])`
`http_request`	`async.http_request(spec, [scope_id])`
`sleep`	`async.sleep(milliseconds, [scope_id])`
`sura`	`async.sura(spec, [scope_id])`
`status`	`async.status(task_id)`
`pending`	`async.pending()`
`forget`	`async.forget(task_id)`
`cleanup`	`async.cleanup()`
`cancel`	`async.cancel(task_id)`
`cancelled`	`async.cancelled(task_id)`
`configure`	`async.configure(max_workers, max_queue)`
`limits`	`async.limits()`
`scope`	`async.scope()`
`scope_open`	`async.scope_open()`
`scope_attach`	`async.scope_attach(scope_id, task_id)`
`scope_cancel`	`async.scope_cancel(scope_id)`
`scope_status`	`async.scope_status(scope_id)`
`scope_close`	`async.scope_close(scope_id, [milliseconds])`
`scope_join`	`async.scope_join(scope_id, [milliseconds])`
`await`	`async.await(task_id)`
`await_timeout`	`async.await_timeout(task_id, milliseconds, [default])`
`ready_all`	`async.ready_all(task_ids)`
`any`	`async.any(task_ids, [milliseconds], [default])`
`all`	`async.all(task_ids)`
`all_timeout`	`async.all_timeout(task_ids, milliseconds, [default])`

autograd — typed Tensor, reverse-mode 자동미분, CPU/CUDA 연산, optimizer와 bounded CPU ONNX 실행63 signatures

이름	호출 서명
`tensor`	`autograd.tensor(data, [options])`
`parameter`	`autograd.parameter(data, [dtype_or_options])`
`zeros`	`autograd.zeros(shape, [options])`
`ones`	`autograd.ones(shape, [options])`
`randn`	`autograd.randn(shape, [options])`
`data`	`autograd.data(tensor)`
`grad`	`autograd.grad(tensor)`
`dtype`	`autograd.dtype(tensor)`
`device`	`autograd.device(tensor)`
`to`	`autograd.to(tensor, device)`
`storage_bytes`	`autograd.storage_bytes(tensor)`
`cast`	`autograd.cast(tensor, dtype)`
`shape`	`autograd.shape(tensor)`
`numel`	`autograd.numel(tensor)`
`limits`	`autograd.limits()`
`item`	`autograd.item(tensor)`
`detach`	`autograd.detach(tensor)`
`requires_grad`	`autograd.requires_grad(tensor)`
`set_requires_grad`	`autograd.set_requires_grad(tensor, requires_grad)`
`add`	`autograd.add(a, b)`
`sub`	`autograd.sub(a, b)`
`mul`	`autograd.mul(a, b)`
`div`	`autograd.div(a, b)`
`neg`	`autograd.neg(tensor)`
`reshape`	`autograd.reshape(tensor, shape)`
`matmul`	`autograd.matmul(a, b, [options])`
`transpose`	`autograd.transpose(tensor, [axis1], [axis2])`
`linear`	`autograd.linear(input, weights, [bias])`
`relu`	`autograd.relu(tensor)`
`tanh`	`autograd.tanh(tensor)`
`sigmoid`	`autograd.sigmoid(tensor)`
`gelu`	`autograd.gelu(tensor)`
`layer_norm`	`autograd.layer_norm(tensor, [weight], [bias], [epsilon])`
`embedding`	`autograd.embedding(token_ids, weight)`
`causal_attention`	`autograd.causal_attention(query, key, value, [options])`
`softmax`	`autograd.softmax(tensor)`
`sum`	`autograd.sum(tensor)`
`mean`	`autograd.mean(tensor)`
`mse`	`autograd.mse(prediction, target)`
`bce`	`autograd.bce(probabilities, target)`
`bce_logits`	`autograd.bce_logits(logits, target)`
`cross_entropy`	`autograd.cross_entropy(logits, one_hot_targets)`
`cross_entropy_ids`	`autograd.cross_entropy_ids(logits, class_ids)`
`backward`	`autograd.backward(tensor, [gradient], [retain_graph])`
`zero_grad`	`autograd.zero_grad(parameters)`
`sgd`	`autograd.sgd(parameters, learning_rate, [options])`
`adam`	`autograd.adam(parameters, learning_rate, [options])`
`reset_optimizer`	`autograd.reset_optimizer(parameters)`
`grad_norm`	`autograd.grad_norm(parameters)`
`clip_grad_norm`	`autograd.clip_grad_norm(parameters, max_norm)`
`save_checkpoint`	`autograd.save_checkpoint(state_dict, path, [options])`
`load_checkpoint`	`autograd.load_checkpoint(path, [options])`
`cuda_available`	`autograd.cuda_available()`
`cuda_info`	`autograd.cuda_info()`
`cuda_stats`	`autograd.cuda_stats()`
`cuda_reset_stats`	`autograd.cuda_reset_stats()`
`cuda_synchronize`	`autograd.cuda_synchronize()`
`save_safetensors`	`autograd.save_safetensors(state_dict, path)`
`load_safetensors`	`autograd.load_safetensors(path, [options])`
`save_onnx_weights`	`autograd.save_onnx_weights(state_dict, path)`
`load_onnx_weights`	`autograd.load_onnx_weights(path, [options])`
`run_onnx`	`autograd.run_onnx(path, inputs, [options])`
`all_reduce_gradients`	`autograd.all_reduce_gradients(parameters, options)`

cli — 스크립트 인자와 명령행 문자열 파싱4 signatures

이름	호출 서명
`parse`	`cli.parse(text, [value_flags])`
`argv`	`cli.argv()`
`argc`	`cli.argc()`
`script_name`	`cli.script_name()`

crypto — SHA-256, HMAC, 인코딩, URL·header·cookie 도우미38 signatures

이름	호출 서명
`sha256`	`crypto.sha256(text)`
`file_sha256`	`crypto.file_sha256(path)`
`hmac_sha256`	`crypto.hmac_sha256(key, message)`
`file_hmac_sha256`	`crypto.file_hmac_sha256(key, path)`
`random_bytes`	`crypto.random_bytes(count)`
`random_hex`	`crypto.random_hex(count)`
`constant_time_eq`	`crypto.constant_time_eq(left, right)`
`hex_encode`	`crypto.hex_encode(text)`
`hex_decode`	`crypto.hex_decode(text)`
`base64_encode`	`crypto.base64_encode(text)`
`base64_decode`	`crypto.base64_decode(text)`
`base64_url_encode`	`crypto.base64_url_encode(text)`
`base64_url_decode`	`crypto.base64_url_decode(text)`
`url_encode`	`crypto.url_encode(text)`
`url_decode`	`crypto.url_decode(text)`
`url_parse`	`crypto.url_parse(url)`
`url_build`	`crypto.url_build(parts)`
`query_build`	`crypto.query_build(params)`
`query_parse`	`crypto.query_parse(query)`
`form_build`	`crypto.form_build(params)`
`form_parse`	`crypto.form_parse(body)`
`auth_bearer`	`crypto.auth_bearer(token)`
`auth_basic`	`crypto.auth_basic(username, password)`
`headers_merge`	`crypto.headers_merge(headers, ...)`
`headers_get`	`crypto.headers_get(headers, name, [default])`
`headers_has`	`crypto.headers_has(headers, name)`
`headers_redact`	`crypto.headers_redact(headers, [names], [mask])`
`cookie_parse`	`crypto.cookie_parse(header_or_headers)`
`cookie_build`	`crypto.cookie_build(cookies)`
`cookie_get`	`crypto.cookie_get(header_or_cookies, name, [default])`
`content_type`	`crypto.content_type(headers_or_value, [default])`
`charset`	`crypto.charset(headers_or_value, [default])`
`is_json`	`crypto.is_json(headers_or_value)`
`status_ok`	`crypto.status_ok(status)`
`status_text`	`crypto.status_text(status)`
`status_retryable`	`crypto.status_retryable(status)`
`retry_after`	`crypto.retry_after(headers_or_value, [default_ms])`
`backoff_delays`	`crypto.backoff_delays(attempts, [base_ms], [factor], [max_ms])`

dataset — uint32 text shard 생성과 seek 기반 batch reader6 signatures

이름	호출 서명
`pack_text`	`dataset.pack_text(source, tokenizer, path, [options])`
`open`	`dataset.open(path, [options])`
`next`	`dataset.next(loader)`
`reset`	`dataset.reset(loader, [epoch])`
`close`	`dataset.close(loader)`
`info`	`dataset.info(loader)`

datetime — 현재 시각, 형식화, 파싱, 날짜 계산8 signatures

이름	호출 서명
`now`	`datetime.now()`
`parse`	`datetime.parse(text, [format])`
`format`	`datetime.format(timestamp, format)`
`utc_format`	`datetime.utc_format(timestamp, format)`
`parts`	`datetime.parts(timestamp, [utc])`
`add`	`datetime.add(timestamp, seconds)`
`diff`	`datetime.diff(end_timestamp, start_timestamp)`
`timestamp`	`datetime.timestamp()`

db — 파일 기반 key/value와 record 작업12 signatures

이름	호출 서명
`set`	`db.set(path, key, value)`
`get`	`db.get(path, key, [default])`
`has`	`db.has(path, key)`
`delete`	`db.delete(path, key)`
`keys`	`db.keys(path)`
`all`	`db.all(path)`
`insert`	`db.insert(path, row)`
`find`	`db.find(path, criteria)`
`count`	`db.count(path, [criteria])`
`update`	`db.update(path, criteria, patch)`
`remove`	`db.remove(path, criteria)`
`query`	`db.query(path, [criteria], [options])`

fs — 파일·디렉터리 읽기, 쓰기, 탐색, 이동21 signatures

이름	호출 서명
`read`	`fs.read(path)`
`write`	`fs.write(path, text)`
`read_json`	`fs.read_json(path)`
`write_json`	`fs.write_json(path, value)`
`read_bytes`	`fs.read_bytes(path)`
`write_bytes`	`fs.write_bytes(path, bytes)`
`sha256`	`fs.sha256(path)`
`append`	`fs.append(path, text)`
`exists`	`fs.exists(path)`
`delete`	`fs.delete(path)`
`remove_tree`	`fs.remove_tree(path)`
`list`	`fs.list(path)`
`walk`	`fs.walk(path, [extension])`
`glob`	`fs.glob(pattern)`
`mkdir`	`fs.mkdir(path)`
`cwd`	`fs.cwd()`
`join`	`fs.join(part, ...)`
`basename`	`fs.basename(path)`
`dirname`	`fs.dirname(path)`
`copy`	`fs.copy(src, dst, [overwrite])`
`move`	`fs.move(src, dst, [overwrite])`

dict — dictionary keys·values·merge·pick·path7 signatures

이름	호출 서명
`keys`	`dict.keys(dict)`
`values`	`dict.values(dict)`
`items`	`dict.items(dict)`
`merge`	`dict.merge(dict, ...)`
`pick`	`dict.pick(dict, keys)`
`omit`	`dict.omit(dict, keys)`
`get_path`	`dict.get_path(value, path, [default])`

ffi — 동적 C ABI library load와 symbol call2 signatures

이름	호출 서명
`load`	`ffi.load(path)`
`call`	`ffi.call(lib, symbol, signature, ...args)`

graphics3d — 4x4 matrix, cube mesh, transform, bounds, camera projection10 signatures

이름	호출 서명
`identity`	`graphics3d.identity()`
`translate`	`graphics3d.translate(x, y, z)`
`scale`	`graphics3d.scale(x, y, z)`
`rotate_y`	`graphics3d.rotate_y(radians)`
`mul`	`graphics3d.mul(left, right)`
`cube`	`graphics3d.cube([size], [center])`
`transform`	`graphics3d.transform(mesh, matrix4)`
`bounds`	`graphics3d.bounds(mesh)`
`face_normals`	`graphics3d.face_normals(mesh)`
`project`	`graphics3d.project(point, camera, [width], [height])`

http — HTTP client, retry, local server, URL·form·header helpers37 signatures

이름	호출 서명
`get`	`http.get(url)`
`json`	`http.json(url)`
`post`	`http.post(url, body, [content_type])`
`request`	`http.request(spec)`
`request_full`	`http.request_full(spec)`
`request_retry`	`http.request_retry(spec, [attempts], [delay_ms])`
`request_json`	`http.request_json(spec)`
`request_json_checked`	`http.request_json_checked(spec)`
`request_retry_json`	`http.request_retry_json(spec, [attempts], [delay_ms])`
`request_retry_json_checked`	`http.request_retry_json_checked(spec, [attempts], [delay_ms])`
`serve_static`	`http.serve_static(path, [port])`
`serve_routes`	`http.serve_routes(routes, [port])`
`server_url`	`http.server_url(server)`
`server_stop`	`http.server_stop(server)`
`url_parse`	`http.url_parse(url)`
`url_build`	`http.url_build(parts)`
`query_build`	`http.query_build(params)`
`query_parse`	`http.query_parse(query)`
`form_build`	`http.form_build(params)`
`form_parse`	`http.form_parse(body)`
`auth_bearer`	`http.auth_bearer(token)`
`auth_basic`	`http.auth_basic(username, password)`
`headers_merge`	`http.headers_merge(headers, ...)`
`headers_get`	`http.headers_get(headers, name, [default])`
`headers_has`	`http.headers_has(headers, name)`
`headers_redact`	`http.headers_redact(headers, [names], [mask])`
`cookie_parse`	`http.cookie_parse(header_or_headers)`
`cookie_build`	`http.cookie_build(cookies)`
`cookie_get`	`http.cookie_get(header_or_cookies, name, [default])`
`content_type`	`http.content_type(headers_or_value, [default])`
`charset`	`http.charset(headers_or_value, [default])`
`is_json`	`http.is_json(headers_or_value)`
`status_ok`	`http.status_ok(status)`
`status_text`	`http.status_text(status)`
`status_retryable`	`http.status_retryable(status)`
`retry_after`	`http.retry_after(headers_or_value, [default_ms])`
`backoff_delays`	`http.backoff_delays(attempts, [base_ms], [factor], [max_ms])`

json — JSON·JSONL·SSE·CSV·INI 변환, path와 schema 검사28 signatures

이름	호출 서명
`parse`	`json.parse(text)`
`try_parse`	`json.try_parse(text, [fallback])`
`stringify`	`json.stringify(value)`
`pretty`	`json.pretty(value, [indent])`
`path`	`json.path(value, path, [default])`
`get_path`	`json.get_path(value, path, [default])`
`has_path`	`json.has_path(value, path)`
`merge_patch`	`json.merge_patch(target, patch)`
`delete_path`	`json.delete_path(value, path)`
`set_path`	`json.set_path(value, path, new_value)`
`schema_validate`	`json.schema_validate(value, schema)`
`schema_errors`	`json.schema_errors(value, schema)`
`schema_to_json_schema`	`json.schema_to_json_schema(schema, [strict])`
`to_json_schema`	`json.to_json_schema(schema, [strict])`
`template_render`	`json.template_render(text, data, [missing])`
`render`	`json.render(text, data, [missing])`
`pluck`	`json.pluck(rows, path, [default])`
`count_by`	`json.count_by(rows, path)`
`group_by`	`json.group_by(rows, path)`
`sort_by`	`json.sort_by(rows, path, [descending])`
`jsonl_parse`	`json.jsonl_parse(text)`
`jsonl_stringify`	`json.jsonl_stringify(rows, [trailing_newline])`
`sse_parse`	`json.sse_parse(text)`
`sse_data`	`json.sse_data(text, [parse_json])`
`csv_parse`	`json.csv_parse(text, [has_header])`
`csv_stringify`	`json.csv_stringify(rows, [headers])`
`ini_parse`	`json.ini_parse(text)`
`ini_stringify`	`json.ini_stringify(dict)`

llm — model HTTP request 조립, schema, tool call, usage·cost 처리30 signatures

이름	호출 서명
`message`	`llm.message(role, content)`
`messages`	`llm.messages([system], user)`
`rag_messages`	`llm.rag_messages(question, context, [system])`
`request`	`llm.request(model, messages, [temperature])`
`request_json`	`llm.request_json(model, messages, [temperature])`
`response_schema`	`llm.response_schema(name, schema, [strict])`
`request_schema`	`llm.request_schema(model, messages, schema, [temperature], [name], [strict])`
`request_schema_json`	`llm.request_schema_json(model, messages, schema, [temperature], [name], [strict])`
`tools`	`llm.tools([names])`
`tool_schemas`	`llm.tool_schemas([names])`
`request_tools`	`llm.request_tools(model, messages, tool_names, [temperature])`
`request_tools_json`	`llm.request_tools_json(model, messages, tool_names, [temperature])`
`request_tools_schema`	`llm.request_tools_schema(model, messages, tool_names, schema, [temperature], [name], [strict])`
`request_tools_schema_json`	`llm.request_tools_schema_json(model, messages, tool_names, schema, [temperature], [name], [strict])`
`extract_text`	`llm.extract_text(response)`
`extract_json`	`llm.extract_json(response, [schema])`
`usage`	`llm.usage(response)`
`cost`	`llm.cost(response, pricing)`
`budget`	`llm.budget(response, pricing, limit)`
`tool_calls`	`llm.tool_calls(response)`
`tool_result`	`llm.tool_result(call_or_id, result)`
`run_tools`	`llm.run_tools(response, policy)`
`next_messages`	`llm.next_messages(messages, response, policy)`
`next_request`	`llm.next_request(model, messages, response, policy, tool_names, [temperature])`
`next_request_json`	`llm.next_request_json(model, messages, response, policy, tool_names, [temperature])`
`next_schema_request`	`llm.next_schema_request(model, messages, response, policy, tool_names, schema, [temperature], [name], [strict])`
`next_schema_request_json`	`llm.next_schema_request_json(model, messages, response, policy, tool_names, schema, [temperature], [name], [strict])`
`stream_text`	`llm.stream_text(sse_or_chunks)`
`chat`	`llm.chat(endpoint, api_key, model, messages, [temperature])`
`chat_request`	`llm.chat_request(endpoint, api_key, request)`

log — level, text/JSON event, file output10 signatures

이름	호출 서명
`set_file`	`log.set_file(path, [append])`
`set_json`	`log.set_json(enabled)`
`set_level`	`log.set_level(level)`
`get_level`	`log.get_level()`
`level`	`log.level([level])`
`event`	`log.event(level, message, [fields])`
`debug`	`log.debug(message)`
`info`	`log.info(message)`
`warn`	`log.warn(message)`
`error`	`log.error(message)`

math — 수학 함수, clamp, min/max, 난수14 signatures

이름	호출 서명
`sqrt`	`math.sqrt(value)`
`sin`	`math.sin(value)`
`cos`	`math.cos(value)`
`tan`	`math.tan(value)`
`floor`	`math.floor(value)`
`ceil`	`math.ceil(value)`
`round`	`math.round(value)`
`abs`	`math.abs(value)`
`sign`	`math.sign(value)`
`pow`	`math.pow(base, exponent)`
`min`	`math.min(value, ...)`
`max`	`math.max(value, ...)`
`clamp`	`math.clamp(value, min, max)`
`random`	`math.random([max]) \| math.random(min, max)`

nn — CPU dense MLP 생성·학습·평가·JSON 저장13 signatures

이름	호출 서명
`mlp`	`nn.mlp(layer_sizes, [options])`
`forward`	`nn.forward(model, inputs)`
`predict`	`nn.predict(model, inputs)`
`train`	`nn.train(model, inputs, targets, [options])`
`classify`	`nn.classify(model, inputs, [threshold])`
`evaluate`	`nn.evaluate(model, inputs, targets, [options])`
`summary`	`nn.summary(model)`
`one_hot`	`nn.one_hot(labels, class_count)`
`fit_standardizer`	`nn.fit_standardizer(inputs)`
`standardize`	`nn.standardize(inputs, standardizer)`
`split`	`nn.split(inputs, targets, [options])`
`save`	`nn.save(model, path)`
`load`	`nn.load(path)`

os — 환경 변수, argv, 경로, command 실행, sleep22 signatures

이름	호출 서명
`env_get`	`os.env_get(name, [default])`
`env_require`	`os.env_require(name)`
`env_set`	`os.env_set(name, value)`
`env_load`	`os.env_load(path, [override])`
`argv`	`os.argv()`
`argc`	`os.argc()`
`script_name`	`os.script_name()`
`cwd`	`os.cwd()`
`home_dir`	`os.home_dir()`
`temp_dir`	`os.temp_dir()`
`path_separator`	`os.path_separator()`
`name`	`os.name()`
`is_windows`	`os.is_windows()`
`which`	`os.which(command)`
`cmd_exists`	`os.cmd_exists(command)`
`cmd_quote`	`os.cmd_quote(text)`
`cmd_join`	`os.cmd_join(args)`
`run`	`os.run(command)`
`run_checked`	`os.run_checked(command)`
`cmd`	`os.cmd(command)`
`sleep_ms`	`os.sleep_ms(milliseconds)`
`wait`	`os.wait(milliseconds)`

path — 경로 결합·정규화·상대/절대 경로8 signatures

이름	호출 서명
`join`	`path.join(part, ...)`
`basename`	`path.basename(path)`
`dirname`	`path.dirname(path)`
`ext`	`path.ext(path)`
`stem`	`path.stem(path)`
`normalize`	`path.normalize(path)`
`abs`	`path.abs(path)`
`relative`	`path.relative(path, [base])`

media — 픽셀과 로컬 영상을 문자 프레임으로 변환6 signatures

이름	호출 서명
`available`	`media.available([ffmpeg_path])`
`ffmpeg_available`	`media.ffmpeg_available([ffmpeg_path])`
`frame_to_text`	`media.frame_to_text(pixels, [options])`
`ascii_frames`	`media.ascii_frames(path, [options])`
`video_to_text`	`media.video_to_text(path, [options])`
`video_text_frames`	`media.video_text_frames(path, [options])`

plugin — Sura plugin ABI library load·call·lifecycle5 signatures

이름	호출 서명
`load`	`plugin.load(path)`
`load_manifest`	`plugin.load_manifest(path)`
`call`	`plugin.call(plugin, export, ...args)`
`info`	`plugin.info(plugin)`
`unload`	`plugin.unload(plugin)`

python — 선택형 Python interpreter 탐색·eval·module call5 signatures

이름	호출 서명
`available`	`python.available()`
`executable`	`python.executable()`
`eval`	`python.eval(code)`
`call`	`python.call(module, function, [args], [kwargs])`
`call_json`	`python.call_json(module, function, [args], [kwargs])`

rag — 검색 결과를 context·source·message 형태로 조립4 signatures

이름	호출 서명
`context`	`rag.context(query, docs, [k], [embedding_field], [text_field])`
`sources`	`rag.sources(query, docs, [k], [embedding_field], [text_field], [title_field])`
`prepare`	`rag.prepare(question, query, docs, [k], [embedding_field], [text_field], [system], [title_field])`
`messages`	`rag.messages(question, context, [system])`

random — seed 기반 숫자·선택·shuffle·bytes·UUID8 signatures

이름	호출 서명
`seed`	`random.seed(seed)`
`int`	`random.int(max) \| random.int(min, max)`
`float`	`random.float([max]) \| random.float(min, max)`
`bool`	`random.bool([probability])`
`choice`	`random.choice(array)`
`shuffle`	`random.shuffle(array)`
`bytes`	`random.bytes(count)`
`uuid`	`random.uuid()`

regex — 정규식 match·replace·capture·split7 signatures

이름	호출 서명
`match`	`regex.match(text, pattern)`
`replace`	`regex.replace(text, pattern, replacement)`
`find_all`	`regex.find_all(text, pattern)`
`escape`	`regex.escape(text)`
`capture`	`regex.capture(text, pattern)`
`captures`	`regex.captures(text, pattern)`
`split`	`regex.split(text, pattern)`

set — 배열 기반 합집합·교집합·차집합6 signatures

이름	호출 서명
`union`	`set.union(array, ...)`
`intersection`	`set.intersection(array, ...)`
`difference`	`set.difference(array, ...)`
`symmetric_difference`	`set.symmetric_difference(left, right)`
`is_subset`	`set.is_subset(left, right)`
`is_superset`	`set.is_superset(left, right)`

stream — lazy stream map·filter·window·batch·집계14 signatures

이름	호출 서명
`from`	`stream.from(array_or_text)`
`next`	`stream.next(stream)`
`collect`	`stream.collect(stream)`
`take`	`stream.take(stream, count)`
`batch`	`stream.batch(stream, size)`
`map`	`stream.map(stream, path, [fallback])`
`filter`	`stream.filter(stream, criteria)`
`window`	`stream.window(stream, size, [step])`
`skip`	`stream.skip(stream, count)`
`count`	`stream.count(stream)`
`join`	`stream.join(stream, [separator])`
`sum`	`stream.sum(stream, [path])`
`avg`	`stream.avg(stream, [path])`
`lines`	`stream.lines(path)`

string — 문자열 길이·분할·검색·치환·padding·chunk20 signatures

이름	호출 서명
`len`	`string.len(text)`
`length`	`string.length(text)`
`size`	`string.size(text)`
`split`	`string.split(text, separator)`
`join`	`string.join(array, separator)`
`trim`	`string.trim(text)`
`upper`	`string.upper(text)`
`lower`	`string.lower(text)`
`contains`	`string.contains(text, needle)`
`starts_with`	`string.starts_with(text, prefix)`
`ends_with`	`string.ends_with(text, suffix)`
`index_of`	`string.index_of(text, needle)`
`sub`	`string.sub(text, start, [end])`
`replace`	`string.replace(text, from, to)`
`lines`	`string.lines(text)`
`words`	`string.words(text)`
`repeat`	`string.repeat(text, count)`
`pad_left`	`string.pad_left(text, width, [fill])`
`pad_right`	`string.pad_right(text, width, [fill])`
`chunks`	`string.chunks(text, [max_chars], [overlap])`

tensor — 일반 배열 기반 tensor 연산과 통계19 signatures

이름	호출 서명
`shape`	`tensor.shape(tensor)`
`zeros`	`tensor.zeros(shape)`
`fill`	`tensor.fill(shape, value)`
`add`	`tensor.add(a, b)`
`mul`	`tensor.mul(a, b)`
`clip`	`tensor.clip(tensor, min, max)`
`flatten`	`tensor.flatten(tensor)`
`sum`	`tensor.sum(tensor)`
`mean`	`tensor.mean(tensor)`
`variance`	`tensor.variance(tensor)`
`std`	`tensor.std(tensor)`
`min`	`tensor.min(tensor)`
`max`	`tensor.max(tensor)`
`argmin`	`tensor.argmin(tensor)`
`argmax`	`tensor.argmax(tensor)`
`zscore`	`tensor.zscore(tensor)`
`softmax`	`tensor.softmax(tensor)`
`transpose`	`tensor.transpose(matrix)`
`matmul`	`tensor.matmul(a, b)`

test — assertion, check, summary, report16 signatures

이름	호출 서명
`assert`	`test.assert(condition, [message])`
`eq`	`test.eq(actual, expected, [message])`
`ne`	`test.ne(actual, expected, [message])`
`neq`	`test.neq(actual, expected, [message])`
`contains`	`test.contains(container, value, [message])`
`not_contains`	`test.not_contains(container, value, [message])`
`match`	`test.match(text, pattern, [message])`
`type`	`test.type(value, type, [message])`
`len`	`test.len(value, length, [message])`
`between`	`test.between(value, min, max, [message])`
`approx`	`test.approx(actual, expected, [epsilon], [message])`
`check`	`test.check(name, condition, [message])`
`check_eq`	`test.check_eq(name, actual, expected, [message])`
`check_match`	`test.check_match(name, text, pattern, [message])`
`summary`	`test.summary(results)`
`report`	`test.report(results, [title])`

tokenizer — UTF-8 raw-byte와 bounded byte-level BPE tokenizer, tokenizer 파일7 signatures

이름	호출 서명
`byte`	`tokenizer.byte([options])`
`train_bpe`	`tokenizer.train_bpe(corpus, [options])`
`encode`	`tokenizer.encode(tokenizer, text, [options])`
`decode`	`tokenizer.decode(tokenizer, ids, [options])`
`info`	`tokenizer.info(tokenizer)`
`save`	`tokenizer.save(tokenizer, path)`
`load`	`tokenizer.load(path)`

tool — 도구 schema·policy 검사와 호출7 signatures

이름	호출 서명
`call`	`tool.call(spec)`
`spec`	`tool.spec(name, args)`
`validate`	`tool.validate(spec)`
`schema`	`tool.schema(name)`
`allowed`	`tool.allowed(spec, policy)`
`call_policy`	`tool.call_policy(spec, policy)`
`list`	`tool.list()`

vector — 2D/3D vector, cosine, normalize, transform, search24 signatures

이름	호출 서명
`vec3`	`vector.vec3(x, y, z)`
`add`	`vector.add(a, b)`
`dot`	`vector.dot(a, b)`
`scale`	`vector.scale(vector, scalar)`
`norm`	`vector.norm(vector)`
`add3`	`vector.add3(a, b)`
`sub3`	`vector.sub3(a, b)`
`dot3`	`vector.dot3(a, b)`
`cross`	`vector.cross(a, b)`
`scale3`	`vector.scale3(vector, scalar)`
`norm3`	`vector.norm3(vector)`
`normalize3`	`vector.normalize3(vector)`
`distance3`	`vector.distance3(a, b)`
`neg3`	`vector.neg3(vector)`
`lerp3`	`vector.lerp3(a, b, t)`
`midpoint3`	`vector.midpoint3(a, b)`
`project3`	`vector.project3(vector, onto)`
`reject3`	`vector.reject3(vector, onto)`
`reflect3`	`vector.reflect3(vector, normal)`
`angle3`	`vector.angle3(a, b)`
`transform4`	`vector.transform4(vector, matrix4)`
`cosine`	`vector.cosine(a, b)`
`normalize`	`vector.normalize(vector)`
`search`	`vector.search(query, rows, [k], [field])`

console runtime module

use console은 runtime module object를 만듭니다. 이 module은 현재 surapkg 34-module API metadata 집계에 포함되지 않습니다.

console.log console.print console.write console.write_line console.writeln console.println console.line console.info console.debug console.warn console.warning console.error console.exception console.raw console.flush console.json console.inspect console.hrtime console.beep console.clear console.assert console.time console.time_end console.timeEnd console.time_log console.timeLog console.time_stamp console.timeStamp console.count console.count_reset console.countReset console.table console.dir console.dirxml console.trace console.group console.group_collapsed console.groupCollapsed console.group_end console.groupEnd console.profile console.profile_end console.profileEnd console.style console.color console.colour console.strip_ansi console.stripAnsi console.set_color console.setColor console.set_colour console.setColour console.reset_color console.resetColor console.reset_colour console.resetColour console.is_tty console.isTTY console.width console.height console.size console.status console.input console.read_line console.readline console.readLine console.prompt

664개 global builtin 이름과 alias

global builtin 목록 보기

Error abs append_file argc argv array_avg array_chunk array_count_by array_flatten array_group_by array_len array_length array_max array_min array_pluck array_range array_repeat array_size array_sort_by array_sum array_unique array_zip assert assert_approx assert_between assert_contains assert_eq assert_len assert_match assert_ne assert_neq assert_not_contains assert_type async_all async_all_timeout async_any async_await async_await_timeout async_cancel async_cancelled async_cleanup async_cmd async_configure async_forget async_http_get async_http_request async_limits async_pending async_ready async_ready_all async_scope_attach async_scope_cancel async_scope_close async_scope_join async_scope_open async_scope_status async_sleep async_status async_sura auth_basic auth_bearer autograd_adam autograd_add autograd_all_reduce_gradients autograd_autocast autograd_backward autograd_backward_scaled autograd_bce autograd_bce_logits autograd_cast autograd_causal_attention autograd_clip_grad_norm autograd_cross_entropy autograd_cross_entropy_ids autograd_cuda_available autograd_cuda_info autograd_cuda_reset_stats autograd_cuda_stats autograd_cuda_synchronize autograd_data autograd_detach autograd_device autograd_div autograd_dtype autograd_embedding autograd_gelu autograd_grad autograd_grad_info autograd_grad_norm autograd_item autograd_layer_norm autograd_limits autograd_linear autograd_load_checkpoint autograd_load_onnx_weights autograd_load_safetensors autograd_matmul autograd_mean autograd_mse autograd_mul autograd_neg autograd_numel autograd_ones autograd_parameter autograd_randn autograd_relu autograd_requires_grad autograd_reset_optimizer autograd_reshape autograd_run_onnx autograd_save_checkpoint autograd_save_onnx_weights autograd_save_safetensors autograd_set_requires_grad autograd_sgd autograd_shape autograd_sigmoid autograd_softmax autograd_storage_bytes autograd_sub autograd_sum autograd_tanh autograd_tensor autograd_to autograd_transpose autograd_unscale_gradients autograd_zero_grad autograd_zeros await await_all await_all_timeout await_any await_timeout base64_decode base64_encode base64_url_decode base64_url_encode camera_project ceil check check_eq check_match clamp cli_parse clock clone cls cmd_exists cmd_join cmd_quote cmd_run cmd_run_checked command_exists concat console_assert console_beep console_clear console_color console_colour console_count console_count_reset console_debug console_dir console_dirxml console_error console_exception console_flush console_group console_group_collapsed console_group_end console_height console_hrtime console_info console_input console_inspect console_is_tty console_json console_line console_log console_print console_println console_profile console_profile_end console_prompt console_raw console_readLine console_read_line console_readline console_reset_color console_reset_colour console_set_color console_set_colour console_size console_status console_strip_ansi console_style console_table console_time console_time_end console_time_log console_time_stamp console_trace console_warn console_warning console_width console_write console_write_line console_writeln constant_time_eq contains cookie_build cookie_get cookie_parse copy_file cos count_by crypto_constant_time_eq crypto_random_bytes crypto_random_hex csv_parse csv_stringify cwd dataset_close dataset_info dataset_next dataset_open dataset_pack_text dataset_reset datetime_add datetime_diff datetime_format datetime_now datetime_parse datetime_parts datetime_utc_format db_all db_count db_delete db_find db_get db_has db_insert db_keys db_query db_remove db_set db_update delete_file deserialize dict_get_path dict_items dict_keys dict_merge dict_omit dict_pick dict_values embedding_search endsWith env_get env_load env_require env_set exists ffi_call ffi_load file_append file_copy file_delete file_exists file_glob file_hmac_sha256 file_info file_is_dir file_is_file file_lines file_list file_move file_read file_read_bytes file_read_json file_remove_tree file_sha256 file_size file_walk file_write file_write_bytes file_write_json floor form_build form_parse glob_files grid_clear grid_draw grid_init grid_set group_by headers_get headers_has headers_merge headers_redact hex_decode hex_encode hmac_sha256 hmac_sha256_file home_dir http_backoff_delays http_charset http_content_type http_get http_is_json http_json http_post http_request http_request_full http_request_json http_request_json_checked http_request_retry http_request_retry_json http_request_retry_json_checked http_retry_after http_serve_routes http_serve_static http_server_stop http_server_url http_status_ok http_status_retryable http_status_text indexOf ini_parse ini_stringify input is_dir is_file is_windows join json_delete_path json_has_path json_merge_patch json_parse json_path json_pretty json_set_path json_stringify json_try_parse jsonl_parse jsonl_stringify key_down length list_dir llm_budget llm_chat llm_chat_request llm_cost llm_extract_json llm_extract_text llm_message llm_messages llm_next_messages llm_next_request llm_next_request_json llm_next_schema_request llm_next_schema_request_json llm_request llm_request_json llm_request_schema llm_request_schema_json llm_request_tools llm_request_tools_json llm_request_tools_schema llm_request_tools_schema_json llm_response_schema llm_run_tools llm_stream_text llm_tool_calls llm_tool_result llm_tool_schemas llm_tools llm_usage log_debug log_error log_event log_get_level log_info log_level log_set_file log_set_json log_set_level log_warn lower mat4_identity mat4_mul mat4_rotate_y mat4_scale mat4_translate max media_ascii_frames media_available media_ffmpeg_available media_frame_to_text media_video_text_frames media_video_to_text mesh_bounds mesh_cube mesh_face_normals mesh_transform4 min mkdir mouse_down mouse_pos mouse_x mouse_y move_file nn_classify nn_evaluate nn_fit_standardizer nn_forward nn_load nn_mlp nn_one_hot nn_predict nn_save nn_split nn_standardize nn_summary nn_train os_name path_abs path_basename path_dirname path_ext path_join path_normalize path_relative path_separator path_stem pluck plugin_call plugin_info plugin_load plugin_load_manifest plugin_unload pop pow pretty_json print print_n print_no_nl push python_available python_call python_call_json python_eval python_executable query_build query_parse rag_context rag_messages rag_prepare rag_sources random random_bool random_bytes random_choice random_float random_int random_seed random_shuffle read_file readkey readkey_timeout regex_capture regex_captures regex_escape regex_find_all regex_match regex_replace regex_split remove_tree replace reverse round schema_errors schema_to_json_schema schema_validate script_name secure_compare secure_random_bytes secure_random_hex serialize set_difference set_intersection set_is_subset set_is_superset set_symmetric_difference set_union sha256 sha256_file sign silent sin sleep sleep_ms slice sort sort_by split sqrt sse_data sse_parse startsWith stream_avg stream_batch stream_collect stream_count stream_filter stream_from stream_join stream_lines stream_map stream_next stream_skip stream_sum stream_take stream_window string_contains string_endsWith string_ends_with string_indexOf string_index_of string_len string_length string_lines string_lower string_pad_left string_pad_right string_repeat string_replace string_size string_slice string_startsWith string_starts_with string_sub string_substring string_trim string_upper string_words substring tan task temp_dir template_render tensor_add tensor_argmax tensor_argmin tensor_clip tensor_fill tensor_flatten tensor_matmul tensor_max tensor_mean tensor_min tensor_mul tensor_shape tensor_softmax tensor_std tensor_sum tensor_transpose tensor_variance tensor_zeros tensor_zscore test_report test_summary text_chunk text_chunks timestamp to_bool to_float to_int to_str tokenizer_byte tokenizer_decode tokenizer_encode tokenizer_info tokenizer_load tokenizer_save tokenizer_train_bpe tool tool_allowed tool_call tool_call_policy tool_list tool_schema tool_spec tool_validate trim type upper url_build url_decode url_encode url_parse uuid uuid_v4 vec3 vec3_add vec3_angle vec3_cross vec3_distance vec3_dot vec3_lerp vec3_midpoint vec3_neg vec3_norm vec3_normalize vec3_project vec3_reflect vec3_reject vec3_scale vec3_sub vec3_transform4 vec_add vec_cosine vec_dot vec_norm vec_normalize vec_scale vector3 vector3_add vector3_angle vector3_cross vector3_distance vector3_dot vector3_lerp vector3_midpoint vector3_neg vector3_norm vector3_normalize vector3_project vector3_reflect vector3_reject vector3_scale vector3_sub vector3_transform4 vector_add vector_cosine vector_dot vector_norm vector_normalize vector_scale vector_search wait walk_files which win_circle win_clear win_close win_focus win_init win_line win_poll win_rect win_text win_update write_file

동시성

async module은 thread-per-task 대신 bounded worker pool을 사용합니다. 기본 worker 수는 감지한 hardware concurrency를 1..8로 제한하고 감지 실패 시 4를 사용합니다. pending queue 상한 기본값은 1024입니다. async.limits()가 현재 값을 반환하고 live task와 scope가 없을 때 async.configure(max_workers, max_queue)로 교체합니다. 설정 범위는 worker 1..256, queue 1..1,000,000입니다.

항목	계약
task 종류	`async.cmd`, `async.http_get/http_request`, `async.sleep`, `async.sura`
상태	`queued, running, succeeded, failed, cancelled`
조회	`status, ready, pending, cancelled`
대기	`await, await_timeout, any, all, all_timeout`
수명	`forget, cleanup`
취소	`cancel`; timer checkpoint, command process tree, curl request 종료
scope	`scope, scope_attach, scope_cancel, scope_status, scope_join, scope_close`

scope_cancel은 runtime mutex 아래에서 새 child admission을 닫은 뒤 기존 child snapshot에 cancellation을 요청합니다. scope_join은 기존 child를 기다리고 scope_close는 cancellation을 먼저 요청합니다. join/close는 child handle을 정리한 뒤 보존된 child failure를 전파합니다. timed join/close가 끝나지 않으면 closed: false를 반환하고 해당 scope는 새 child를 받지 않습니다.

완료 결과와 오류는 await·forget·cleanup 또는 scope 수집까지 보관됩니다. await는 terminal handle을 소비합니다. status의 running field는 queued task에도 true이므로 세부 상태는 state와 queued field로 구분합니다.

async.sura({program, input, timeout_ms?}, [scope_id])는 .sura, .sura.bc/.bc, .sura.srp/.srp program을 격리된 자식 Sura process에서 실행합니다. 제출 시 program과 input을 snapshot하며 program·input 각각 64 MiB, JSON input 1,000,000 node·depth 128을 상한으로 둡니다. input은 nil·bool·finite number·string·array·dict만 허용하며 closure·instance·tensor·native resource·cycle을 거부하고 alias identity는 보존하지 않습니다. 기본 timeout은 30,000 ms, 범위는 1..3,600,000 ms입니다. 자식의 argv()[0]이 input JSON을 받고 stdout이 await 결과가 됩니다. nonzero exit는 task failure이며 timeout·cancel은 process tree를 종료합니다. child process 안의 재귀 async.sura는 비활성화됩니다.

임의 Sura closure를 같은 process worker에 spawn하는 API는 없습니다. any/all_timeout은 completion condition variable을 기다립니다. queued cancellation은 FIFO queue에서 즉시 제거됩니다.

file:// async read는 일반 파일만 허용하고 64 KiB chunk마다 cancellation을 확인하며 task 결과를 64 MiB로 제한합니다. command와 curl capture도 64 MiB를 넘으면 process tree를 종료하고 task를 failed 상태로 게시합니다. terminal task output의 runtime 전체 retained budget은 256 MiB이고 retained error는 task당 64 KiB입니다. async.limits()가 max_retained_bytes와 retained_bytes를 반환하며 await·forget·cleanup·scope close가 예산을 반환합니다. HTTP body 임시 파일은 process id와 단조 sequence를 사용해 exclusive-create하며 정상·예외·취소 경로에서 삭제합니다.

use async
scope is async.scope()
first is async.sleep(50, scope)
second is async.cmd("echo sura", scope)
result is async.scope_join(scope, 1000)
print(result)

Tensor·AI·CUDA

영역	구현 범위
`nn`	CPU dense MLP, forward/predict/train/evaluate, Adam·momentum SGD, JSON save/load
`autograd CPU`	row-major typed Tensor, CPU 기본 float64, reverse-mode graph, optimizer와 checkpoint
`autograd CUDA`	CUDA 기본 float32 resident Tensor, f16/bf16 2-byte visible storage, typed matmul, f32 output·gradient·master optimizer
Transformer 구성	reshape, ND-left×rank-2 matmul, transpose, GELU, LayerNorm, embedding, causal_attention, cross_entropy_ids
optimizer	SGD·Adam, weight decay, momentum, transactional finite check, loss scaling
데이터	UTF-8 raw-byte tokenizer, bounded byte-level BPE, byte-token uint32 shard, seek 기반 batch loader
model 교환	Safetensors read/write, PyTorch bridge through Safetensors, ONNX initializer read/write and bounded CPU graph execution
checkpoint	v3 visible weight, f32 master, SGD velocity, Adam moments/step/beta product

resident CUDA graph의 GELU, LayerNorm, embedding, transpose, attention, sparse cross entropy와 output/gradient는 float32입니다. f16/bf16 storage를 직접 소비하는 low-precision 연산은 typed matmul입니다.

현재 CUDA 범위: single-device resident graph, optional dynamically loaded cuBLAS SGEMM/GemmEx, reference PTX fallback, deterministic no-O(T²)-workspace causal-attention backward. tokenizer.train_bpe는 bounded deterministic byte-level BPE 학습·왕복·저장과 chunk-boundary 보존 dataset pack을 제공한다. autograd.run_onnx는 CPU에서 IR 3~10·opset 7~18의 15개 operator subset만 실행하며 전체 축 순열 Transpose, Flatten, bounded INT64-shape Reshape를 포함한다. 현재 미구현 범위: general broadcasting, batched-right matmul, dense softmax/cross-entropy, low activation/output, mixed backward 가속, FlashAttention, KV cache, AdamW, NCCL, 임의 ONNX graph·Conv·동적 shape/control-flow·GPU 실행, 외부 tokenizer 호환, mmap/prefetch.

기본 한도는 Tensor rank 8, Tensor당 10,000,000 elements, graph 1,000,000 nodes, live host buffer 512 MiB, causal-attention score 50,000,000개입니다.

use autograd
x is autograd.tensor([[1, 2]], {device: "cuda"})
w is autograd.parameter([[0.1], [0.2]], {device: "cuda"})
autograd.zero_grad([w])
y is autograd.linear(x, w)
loss is autograd.mean(y)
autograd.backward(loss)
autograd.adam([w], 0.001)

영상 → 문자 프레임

media.frame_to_text는 grayscale/RGB/RGBA pixel matrix를 FFmpeg 없이 변환합니다. media.ascii_frames, media.video_to_text, media.video_text_frames는 로컬 영상 decoding에 FFmpeg를 사용합니다.

use media
options is {width: 80, fps: 8, max_frames: 300, charset: " .:-=+*#%@", dither: true}
clip is media.ascii_frames("clip.mp4", options)
print(clip.frames[0])

옵션	기본값·범위
`width`	80, 1..512
`height`	자동; 지정값 1..512
`char_aspect`	0.5, 0.1..2.0; 자동 높이에 사용
`fps`	8, 0.1..60
`max_frames`	300, 1..10000
`start / duration`	초 단위 decode 구간
`charset`	`" .:-=+*#%@"`; 어두움→밝음 순 UTF-8 glyph
`gamma`	1, 0.1..5.0
`invert / dither`	false / false
`timeout_ms`	120000, 1000..600000

결과 schema는 sura.text-video.v1이며 frames, timestamps, width, height, fps, frame_count, sampled_duration, truncated, charset, gamma, inverted, dithered, backend, decoder, source field를 포함합니다.

hard cap은 frame당 4 Mi pixels, 최종 output 64 MiB, decoded stream 512 MiB, path 8192 bytes입니다. charset은 2..256개 유효 UTF-8 glyph입니다. start 범위는 0..86400초, duration은 0.001..86400초입니다.

FFmpeg 탐색 순서는 option ffmpeg, 환경 변수 SURA_FFMPEG, PATH입니다. 입력은 로컬 일반 파일이며 network URL은 거부됩니다. decoder process는 shell을 거치지 않고 argument array로 실행되고 protocol whitelist는 file과 pipe입니다. video API는 native runtime 경로입니다.

$env:SURA_FFMPEG = "C:\ffmpeg\bin\ffmpeg.exe"
sura video_text.sura

# 또는 Sura options에 ffmpeg 경로 전달
clip is media.ascii_frames("clip.mp4", {ffmpeg: "C:\\ffmpeg\\bin\\ffmpeg.exe"})

FFI·Plugin·Python

경계	계약
C embedding FFI	ABI 1.2.0; 검증된 opaque token handle, set globals, run source, read globals, last_error
FFI result	`SURA_OK, SURA_ERR_LEX, SURA_ERR_PARSE, SURA_ERR_RUNTIME, SURA_ERR_TYPE, SURA_ERR_BUSY, SURA_ERR_INTERNAL`
FFI concurrency	호출 lease와 지연 close; 같은 handle을 다른 host thread가 실행 중 재진입하면 BUSY; process-global heap 때문에 VM call은 전역 lock으로 직렬화
dynamic C call	`ffi.load(path)`, `ffi.call(lib, symbol, signature, ...args)`
runtime FFI call	library를 호출마다 open/symbol lookup/close; 최대 4 argument; integer-like 또는 float/double 또는 char pointer shape
Plugin	ABI 1.1.0; nil/number/bool/string value, host log/alloc/free/cancel, lifecycle, export table, manifest allowlist·SHA-256·quota
Python	`python.available/executable/eval/call/call_json`; 설치된 Python interpreter를 선택적으로 사용

embedding FFI의 globals 갱신은 새 map과 persistent GC root를 모두 만든 뒤 swap합니다. exported call은 C header에서 사용할 수 있고 native exception을 C ABI 밖으로 내보내지 않습니다. string/error getter는 host thread별 OS TLS/FLS buffer를 사용하며 같은 thread의 다음 string/error getter까지 유효합니다.

같은 handle의 다음 sura_run까지 보존되는 값은 nil·bool·number·string·tensor와 이 값들만 도달 가능한 array/dict입니다. function/closure·upvalue·class instance 또는 그 값에 도달하는 array/dict는 한 execution image에 종속됩니다. 성공한 실행에서는 해당 top-level global을 보존 목록에서 제외합니다. 실패한 실행이 기존 persistent container에 run-bound 값을 넣었다면 그 handle의 persistent globals를 비웁니다. graph 검사는 cycle-safe worklist를 사용하고 1,000,000 object에서 제한합니다.

runtime FFI는 string argument와 floating-point argument를 한 호출에 혼합하지 않습니다. C++ object ABI, struct by-value, callback은 일반 지원 범위에 포함되지 않습니다.

plugin timeout cancellation은 plugin이 host의 should_cancel을 확인하는 cooperative 방식입니다. memory quota는 host allocator를 통한 allocation을 집계합니다.

surapkg bind-c는 단순 C ABI header에서 0..4개 integer 또는 char pointer argument wrapper와 지원되는 numeric/string/void return wrapper를 생성합니다.

패키지·개발 도구

package manifest는 sura.pkg.json, lockfile은 sura.lock.json, 설치 directory는 packages/<name>입니다. 기본 local registry는 ./registry이고 SURA_REGISTRY 또는 SURA_REGISTRY_URL로 변경합니다.

dependency spec은 exact version과 ^1.2, ~1.2, >=1.0 <2.0 형식을 지원합니다. resolve는 yanked version을 제외합니다.

도구	기능
VS Code extension	설치된 Sura engine을 `--lsp`로 시작해 diagnostics, completion, hover, definition/reference, rename, format, semantic tokens, code action을 사용하며 서버를 시작할 수 없으면 기본 completion/hover/signature provider로 전환
`sura --lsp`	incremental LSP, completion, hover, signature, symbols, diagnostics, definition/reference, format, rename, code action
`--debug-protocol`	VS Code DAP line breakpoint, step, stack, locals, watch, exception stop
`--format / --format-check`	source formatting
`--lint`	static lint와 risky API 진단
`--profile / --profile-json`	call·arithmetic·branch·JIT feedback
`--gc-stats / --gc-stats-json`	최종 full collection을 포함한 collection 수, 회수 object 수, total/max/average pause, 다음 object threshold
`--test / --test-report`	test discovery와 JSON report
`surapkg docs`	HTML, api.json, search-index.json 생성
`surapkg ci / release`	docs, tests, benchmark gate, audit, signature/quality workflow
`version.json`	runtime·웹·VS Code·설치기·MSIX·레퍼런스의 단일 버전 원본
`sura_version_sync.ps1`	버전, 공개 manifest, 웹 메타데이터와 실제 다운로드 파일 크기·SHA-256 일치 검사
`sura_windows_signature_gate.ps1`	직접 배포 실행 파일의 Authenticode 상태·서명자·타임스탬프 기록; 엄격 모드는 unsigned 파일 거부

surapkg CLI 전체 목록

Sura package manager
Usage:
  surapkg new <name> [--json report.json]  Create a runnable starter project with tests and VS Code settings
  surapkg init [name] [--json report.json]  Create sura.pkg.json and src/<name>.sura
  surapkg create <name> [--json report.json]  Create a package skeleton directory
  surapkg agent <name> [--json report.json]  Create an AI automation agent template
  surapkg embed <name> [--json report.json]  Create a native C++ host embedding template
  surapkg version [path] [major|minor|patch|version] [--json report.json]  Show or update package manifest version
  surapkg install <path|file|name[@version|range]> [--json report.json]  Install local or registry package
  surapkg outdated [name] [--json]  Show installed packages with newer registry versions
  surapkg update [name] [--json report.json]  Update installed packages from the registry
  surapkg publish [path] [--dry-run] [--json report.json]  Validate or publish to local/HTTP registry
  surapkg search [query] [--json]  Search local or HTTP registry index
  surapkg stats [name] [--json]  Show local or HTTP registry download/publish stats
  surapkg analytics [name] [--json]  Show public registry download trends and top packages
  surapkg registry-health [path] [--fail-on-warning] [--json]  Summarize local/HTTP registry health and moderation queues
  surapkg recover-token <user> <recovery-code> [new-token] [--json report.json]  Recover a registry account token
  surapkg owners [name] [--json]  List registry package owners
  surapkg yanks [name] [--json]  List yanked registry package versions
  surapkg advisory <name[@version]> --severity high --title text --description text [--json]  Create a registry security advisory
  surapkg advisories [name[@version]] [--fail-on high] [--json]  List or gate registry security advisories
  surapkg yank <name@version> <reason> [--json]  Yank a bad registry package version
  surapkg unyank <name@version> [reason] [--json]  Restore a yanked registry package version
  surapkg report <name[@version]> <reason> [--json]  Report a package for registry review
  surapkg reports [status] [--json]  List registry abuse reports
  surapkg review-report <id> <status> [note] [--json]  Review an abuse report
  surapkg doctor [path] [--json report.json]  Diagnose local Sura, package, registry, and tooling setup
  surapkg clean [path] [--dry-run] [--json report.json]  Remove safe generated logs and temporary smoke outputs
  surapkg index [--json report.json]  Rebuild registry/index.json
  surapkg lock [--json report.json]  Write sura.lock.json for installed dependency graph
  surapkg sign [path] [--json report.json]  Write sura.pkg.sig integrity/keyed/public-key signature
  surapkg sign-policy [path] [--json report.json]  Write sura.tools.sig for a package tool policy
  surapkg verify [path] [--json report.json]  Verify sura.lock.json or a package signature
  surapkg verify-policy [path] [--json report.json]  Verify sura.tools.sig for a package tool policy
  surapkg verify-registry [path] [--json report.json]  Verify local/HTTP registry index, bundles, signatures, metadata
  surapkg trust-key <id> <pem> [--json report.json]  Trust a public signing key for registry/key-dir verification
  surapkg resolve [--json]     Resolve manifest and transitive deps against packages/local/HTTP registry
  surapkg tree [--json]       Show the resolved dependency tree
  surapkg why <name> [--json] Explain why a dependency is in the resolved graph
  surapkg format [path] [--check] [--json report.json]
  surapkg check [path] [--json report.json] [--strict|--legacy-types]  Strict by default
  surapkg lint [path] [--json report.json] [--fail-on-warning]
  surapkg audit [path] [--json report.json] [--sarif report.sarif]  Scan package source for risky APIs
  surapkg policy [path] [--json report.json]  Generate starter sura.tools.json from package tool specs
  surapkg tool-log <jsonl>     Summarize SURA_TOOL_AUDIT_LOG events; use --json for CI
  surapkg bind-c <header.h> [--json report.json]  Generate Sura ffi_call wrappers from simple C/C++ C-ABI headers
  surapkg docs [outdir] [--json report.json]  Generate package HTML docs, api.json, and search-index.json
  surapkg quality [path] [--json report.json]  Score package readiness for CI/release gates
  surapkg ci [path] [--json report.json]  Generate docs, test, optional bench, audit, verify, and quality-check
  surapkg release [path] [--dry-run] [--json report.json]  Generate docs, test, optional bench, sign, quality-check, and publish
  surapkg protect [path]       Compile package main to protected .sura.srp or embedded launcher exe
  surapkg protect-verify <protect-report.json> [--json report.json]  Verify protected release evidence
  surapkg run [path] [--json run.json] [--] [args...]  Run package manifest main with script argv
  surapkg profile [path] [--json profile.json] [--no-jit] [--] [args...]
  surapkg bench [path] [--json bench.json] [--summary bench.md] [--python script.py] [--min-speedup ratio] [--] [args...]
  surapkg bench-dashboard [--out html] [--json report.json] [--summary summary.md] [--release-notes notes.md] [--native-perf native_perf.json]  Generate benchmark dashboard artifacts
  surapkg test [path] [--json file.json|--report file.json] [--junit file.xml] [--no-jit]
  surapkg remove <name> [--json report.json]  Remove an installed package
  surapkg list [--json]        List stdlib, installed packages, and manifest deps
  surapkg info <name> [--json] Show package metadata, benchmark evidence, and exported symbols
  surapkg restore [--json report.json]  Install manifest and transitive dependencies locally

JavaScript·WebAssembly 타깃

타깃	2026-07-17 AST lowering 분류
Native VM/JIT	register VM이 주 실행 경로; Win64 x64 전체 JIT(순수 숫자 함수는 baseline 우선), Linux x86-64 System V baseline, little-endian Windows/Linux/macOS ARM64 AAPCS64 baseline — 두 baseline은 helper를 통해 배열·문자열·딕셔너리까지 네이티브 코드로 내보냅니다
JavaScript	43개 node 중 full 41, ignored 2, partial 0
WebAssembly	43개 node 중 full 27, partial 14, ignored 2

AST JSON은 type annotation의 원래 표기를 source_name에 보존합니다. WASM에서 매개변수와 반환 타입을 모두 float 또는 double로 명시한 최상위 함수는 이 표기를 기준으로 기존 Sura Value ABI export와 함께 함수명__f64 동반 export를 생성합니다. 동반 export는 WebAssembly 호스트가 f64 매개변수와 f64 결과를 직접 사용하며, 원래 함수 이름의 export 계약은 바꾸지 않습니다.

JavaScript의 full 41·ignored 2는 43개 AST node의 lowering 분류입니다. JavaScript의 Python·FFI·plugin·async.cmd는 stub 또는 미지원 경로이며, autograd·media·nn·dataset·tokenizer 등 일부 module은 JavaScript runtime object 목록에 없습니다.

WASM target은 AST JSON frontend와 WAT output을 사용합니다. numeric subset, 일부 tagged Value, array/dict/function/class/exception hint lowering을 포함하며 general dynamic Value/function/class/exception semantics 14개 node가 partial 상태입니다. 전체 audit status는 INCOMPLETE입니다.

OS 개발용 freestanding 기능

uefi-x86_64는 Sura VM, GC, Windows API, C runtime, 외부 assembler·linker 없이 PE32+ EFI application을 직접 만드는 실험 타깃입니다. os/sura_os.sura는 QEMU/OVMF에서 UEFI 진입, GOP framebuffer와 backbuffer 준비, COM1 초기화, ExitBootServices, 픽셀·도형·아이콘·5x7 고정폭 글꼴·소문자 ASCII와 현대 한글용 2-bit 안티앨리어싱 글꼴 렌더링, double-buffer present, physical-page self-check, polling xHCI USB boot keyboard·mouse와 PS/2 fallback, 46x14 graphical terminal, ICH9 AHCI 데이터 디스크, VirtIO-net, Intel HDA 48 kHz signed-16 stereo DMA 출력을 실행합니다. FAT32는 설정·창 상태 호환 영역으로 유지하고, 그래픽 File Explorer와 Text Editor의 문서는 두 번째 SuraFS 파티션에 저장합니다. 한글 폴더·파일 열기, 편집 저장, 재부팅 후 동일 세대·내용 복원, DHCP·ARP·IPv4·UDP·DNS·TCP·HTTP, 입력 가능한 주소창, 유효한 UTF-8 페이지 텍스트, 제한된 HTML/CSS 그래픽 레이아웃까지 QEMU에서 검증됐지만 완성 OS는 아닙니다.

전원 경로는 부팅 중 FADT와 DSDT를 검증해 정적 _S5 패키지, PM1 제어 레지스터, RESET_REG/RESET_VALUE를 기록합니다. shutdown은 ACPI S5, reboot는 FADT reset을 사용하며 두 경로 모두 QEMU에서 실제 exit 0으로 검증됩니다. 일반 AML 실행, suspend, 배터리·열 관리와 물리 하드웨어 검증은 아직 없습니다.

.\SuraLanguage.exe --target uefi-x86_64 --out FEATURES.EFI examples\os\freestanding_features.sura

영역	현재 구현
정수·포인터	`i8/u8/i16/u16/i32/u32/i64/u64/isize/usize/ptr`, `ptr[StructName]`
정적 데이터	`static.zero/bytes/u8/u16/u32/u64/utf8/utf16/struct`
모듈	importing-file 기준 nested relative import, normalized-path 중복 제거, cycle 검사
메모리 레이아웃	typed struct field, natural 또는 packed layout, `sizeof/alignof/offset_of`
포인터	`ptr.add/index/field/align_up/align_down/is_aligned`와 width-correct field load/store
저수준 CPU	raw memory, port I/O, CR0/2/3/4, MSR, GDT, IDT, INVLPG, CPUID, RDTSC/RDTSCP, XGETBV/XSETBV
원자 연산	8/16/32/64-bit load, store, exchange, compare-exchange, fetch-add/sub, fence
인터럽트 ABI	`interrupt/interrupt_error` 함수, general-purpose register frame, error-code normalization, saved-CS conditional SWAPGS/LFENCE, checked IDT gate, `iretq`
CPU별 상태	TSS RSP/IST, checked TSS descriptor, LGDT/LIDT, segment reload, LTR/STR, FXSAVE/XSAVE, XSETBV, SWAPGS
SMP primitive	GS-relative per-CPU storage, runtime xAPIC/x2APIC access, EOI, ICR, IPI, INIT, SIPI
페이징 primitive	4-level page-table index, entry read/write/map/clear, CR3 root activation, INVLPG, local TLB flush
메모리 라이브러리	UEFI memory-map bitmap physical allocator, aligned contiguous allocation, conflict-checked 4-level walk/map/unmap/protect/translate
Context primitive	72-byte aligned task frame, nonvolatile GP register/RSP switch, entry(argument), exit_handler(result)
스케줄러 라이브러리	single-CPU cooperative round-robin, create/yield/sleep/block/wake/join/reap
선점형 스케줄러·타이머	checked 152-byte ring-0 interrupt frames, CLI/IRETQ resume, APIC periodic/one-shot timer, bounded PIT calibration, TSC deadline
소프트웨어 인터럽트 syscall	indirect Win64 calls, INT vector invocation, fixed handler table and five-argument dispatch
Ring 3·빠른 syscall	checked IRETQ user entry/resume, 168-byte user frame, SYSCALL/SYSRETQ, STAR/LSTAR/FMASK, GS-relative kernel stack, validated return address and sanitized RFLAGS
사용자 프로세스	fixed-capacity single-CPU round-robin, per-process CR3/TSS RSP0/user GS, timer/yield, blocking IPC wait, Ring-0 service slice, exit, page-fault termination, reap; QEMU에서 선점·CR3·IPC·fault 격리, 무한 루프 중 입력 루프 복귀, 다섯 실제 데스크톱 작업자의 지속 프로세스 실행 검증
프로세스 IPC syscall	`getpid/send/receive/yield/exit/wait`, checked user copy, authenticated sender/target, blocking event wait; wait/wake/receive/exit QEMU 실행 검증
TLS 1.3·X.509 기반	`sha256.sura`·`sha384.sura`·`hkdf_sha256.sura`·`aes128_gcm.sura`·`x25519.sura`·`tls13_record.sura`·`tls13_handshake.sura`·`tls13_messages.sura`·`tls13_verify.sura`·`rsa_sha256.sura`·`rsa_sha384.sura`·`der.sura`·`x509_chain.sura`; ExitBootServices 뒤 RFC/NIST·OpenSSL 및 고정된 공식 루트 벡터로 키 스케줄, record, RDRAND, RSA-PSS/PKCS#1 SHA-256·SHA-384, DER, 인증서 체인·호스트명·시간 검증을 QEMU 실행 검증
PCI 기반 라이브러리	legacy 0xCF8/0xCFC config access, BDF search, capability traversal, BAR decode, command flags
블록 장치 기반	checked synchronous block ABI, RAM disk, boot-stage UEFI Block I/O adapter and media snapshot
ACPI MADT	checked RSDP/XSDT/RSDT discovery, processor and I/O APIC records, interrupt overrides
ACPI 전원	`power.sura`의 checksum-valid FADT/DSDT 탐색, 정적 _S5 package, PM1 SLP_TYP/SLP_EN 종료와 RESET_REG 재시작. 직접 gate와 전체 OS Ring-3 reboot gate가 QEMU exit 0을 실행 검증
NVMe 저장장치	`nvme.sura`의 admin/I/O queue, controller·namespace Identify, PRP1/PRP2 read/write/flush, staged BlockDevice I/O. 직접 gate가 8192-byte 장치·호스트 readback을 확인하고 전체 OS가 NVMe FAT32+SuraFS mount를 실행 검증
AP 시작	16-bit real-mode to 64-bit trampoline, bounded INIT/SIPI sequence, atomic ready handshake
직렬/VM 부팅 게이트	16550 bounded polling, post-ExitBootServices COM1 marker, QEMU/OVMF gate and compile-only mode
그래픽 OS 통합	`os/sura_os.sura`와 `tools/sura_os_vm.ps1`; QEMU TCG에서 double-buffer desktop·AHCI/FAT32 설정 호환·SuraFS 문서 영속 저장·VirtIO TCP/IP/HTTP와 제한된 TLS 1.3 HTTPS·memory self-check·COM1 shell 검증
Framebuffer·글꼴	`framebuffer.sura`의 pixel/line/rectangle/full present/cursor damage copy, `font5x7.sura`의 terminal용 고정폭 bitmap text, `font_ui.sura`의 비례폭 16-pixel 소문자 ASCII·현대 한글 2-bit 안티앨리어싱; QMP screenshot gate로 실제 픽셀 캡처
VirtIO GPU 2D	`virtio_pci.sura`·`virtio_gpu.sura`의 modern PCI capability, VIRTIO_F_VERSION_1 split control queue, 2D resource/backing/scanout/transfer/flush. 전용 QEMU gate가 640x480 화면의 정확한 RGB 픽셀을 검사하고, 전체 OS는 GOP를 유지한 채 미러링과 무장치 fallback을 실행 검증
Intel HDA PCM 출력	`hda.sura`의 PCI/MMIO reset, codec verb, Audio Function Group·output widget 탐색, 48 kHz signed-16 stereo BDL DMA. 전용 QEMU gate가 실제 WAV 형식과 -12000/+12000 샘플을 검사하고, 전체 OS는 bounded startup transfer와 무장치 fallback을 실행 검증
그래픽 터미널	`text_terminal.sura`의 Unicode code-point cells, checked UTF-8 output, wrap, scroll, clear, number output와 ASCII·현대 한글 UI-font draw; 별도 CR3의 CPL 3 UTF-8 줄 편집·명령 인식과 ring 0 특권 명령 실행 검증
창 관리자·데스크톱 셸	`window_manager.sura`의 focus, z-order, hit test, drag, close/show, bounds와 Start·taskbar activation; QEMU PS/2 입력으로 실행 검증
기본 데스크톱 앱	`desktop_apps.sura`의 File Explorer·Text Editor·Calculator state와 System Information snapshot; QEMU에서 각각 별도 CR3를 사용하는 CPL 3 시스템 정보 검증, 폴더 선택, editor 입력·저장, 계산 경로 50-31=19 실행 검증
영속 데이터 디스크	`ahci.sura`·`fat32.sura`·`vfs.sura`·`surafs.sura`로 128 MiB MBR 디스크의 FAT32 호환 파티션과 type-0x7f SuraFS 문서 파티션을 사용. 그래픽 탐색기·편집기의 `/문서/메모.txt` 저장, 디스크 구조 검사, remount-only 두 번째 부팅의 동일 generation·partition SHA-256을 QEMU에서 검증
VirtIO 네트워크·브라우저	`virtio_net.sura`·`net.sura`·`http1.sura`·`gzip.sura`·`http_content.sura`·`os/network.sura`·`os/https.sura`로 split queue, DHCP, ARP, IPv4, UDP DNS, TCP, HTTP/1.1 Content-Length·chunked·connection-close framing, CRC32·ISIZE를 검사하는 bounded gzip/DEFLATE 해제, 제한된 TLS 1.3 HTTPS, 주소 입력, h1/p/a HTML 레이아웃과 CSS 색상 하위 집합을 실행 검증. 주소창의 uncached DNS, 첫 TCP 연결, 첫 TLS handshake는 데스크톱 루프에서 단계적으로 poll되어 대기 중 입력과 취소를 처리하며, `suralang.site` 실접속에서 직접 HTTPS 선택·인증서 검증·암호화 응답·렌더링을 확인
PNG 디코더와 브라우저 연결	`png.sura`의 non-interlaced 8-bit grayscale·grayscale-alpha·RGB·RGBA → RGBA8, multiple IDAT, zlib/Adler-32, chunk CRC32, filter 0~4 처리. 전용 QEMU gate가 모든 필터의 정확한 픽셀과 손상·용량 거부를 실행 검증하고, 전체 OS gate가 live suralang.site의 대용량 PNG를 HTTPS로 받아 두 슬롯 img 경로에서 decode·layout·paint합니다.
JPEG 디코더와 브라우저 연결	`jpeg.sura`의 8-bit baseline sequential Huffman grayscale·YCbCr → RGBA8, 4:4:4·4:2:2·4:2:0 sampling, dequantization, integer IDCT, chroma upsampling. 전용 QEMU gate가 AC color gradient·4:2:0 MCU·grayscale과 오류 거부를 실행 검증하고 브라우저의 두 슬롯 img 경로가 이를 호출합니다. progressive·CMYK는 없으며 live JPEG painting은 별도 gate가 아닙니다.
HTML DOM 기반	`html_dom.sura`의 caller-owned fixed node/attribute tree, parent·child·sibling 관계, UTF-8 text slice, raw script/style text, quoted/unquoted attribute, comment/declaration skip, void element와 bounded ancestor recovery. 전용 QEMU gate와 graphical browser가 DOM box painting, link ancestor hit-test, fragment 이동을 실행 검증
브라우저 JavaScript 기반	`browser_js.sura`·`browser_js_source.sura`·`browser_js_dom.sura`의 caller-owned 고정 용량 bytecode VM·source compiler·DOM host. 정수·문자열·boolean·null·undefined, 전역 선언/대입, 산술·비교, if/else, instruction budget과 host-call ABI를 전용 QEMU gate에서 실행 검증하며, graphical browser는 inline script, inline onclick, getElementById(...).textContent 변경을 `SURA_OS_BROWSER_JS_OK`·`SURA_OS_BROWSER_JS_CLICK_OK`로 검증. 객체·함수·일반 이벤트 모델·다른 Web API는 아직 없음
브라우저 WebAssembly 기반	`browser_wasm.sura`의 caller-owned 고정 용량 MVP 정수 parser/interpreter. custom·type·function·export·code section, i32/i64, direct call, block/loop/if/branch/local/정수 연산을 전용 QEMU gate에서 실행 검증. graphical browser는 WebAssembly magic으로 시작하는 응답의 0인자 run export를 실행하고 결과 42를 `SURA_OS_BROWSER_WASM_OK`·`SURA_OS_BROWSER_WASM_PAGE_OK`로 검증. import·memory·table·global·float·WASI·JIT·JavaScript WebAssembly API·완전한 명세 검증은 아직 없음
CSS 계산 스타일 기반	`css_style.sura`의 caller-owned fixed rule/style arrays, tag·class·ID·inline specificity/source-order cascade, color·font inheritance, display·px와 제한된 상대 크기·min/max·margin/padding/border-width·box-sizing·relative/absolute/fixed position 하위 집합. 전용 QEMU gate와 graphical browser가 inline CSS, 실사이트 same-host 외부 CSS, 계산 스타일을 실행 검증
CSS 박스 레이아웃 기반	`css_box.sura`의 content/border/outer geometry, 세로 block flow, 기본 inline flow·폭 기반 줄바꿈, display:none subtree 제거, relative 이동과 absolute/fixed out-of-flow 배치. 전용 QEMU gate와 graphical browser가 box painting, scrolling, link hit-testing을 실행 검증
RTC·작업 표시줄 시계	`rtc.sura`의 CMOS 안정 샘플·BCD/12시간 변환과 HH:MM 표시; QEMU에서 `SURA_OS_RTC_OK` 실행 검증
PS/2 fallback 입력	`ps2.sura`의 translated Set-1 keyboard, 기본 three-byte mouse, IntelliMouse sample-rate 협상과 four-byte wheel packet polling; xHCI 두 장치 열거가 실패하면 데스크톱 fallback으로 사용
xHCI·USB boot keyboard/mouse	`xhci.sura`·`usb_hid.sura`·`os/input.sura`의 PCI/MMIO, reset/run, 두 root-port 장치 Address Device, endpoint-0 descriptor 전송, Configure Endpoint, interrupt-IN ring, KeyEvent·PointerEvent 변환과 데스크톱 dispatch. 별도 keyboard/mouse gate와 전체 OS gate가 QMP 입력을 실행 검증
Unicode·한글 입력	`key_event.sura`의 물리 키·누름/뗌/반복·Shift/Ctrl/Alt/Caps, `text_input.sura`의 두벌식 조합·조합 중 Backspace·UTF-8, `font_ui.sura`의 소문자 ASCII·현대 한글 atlas; 직접 입력 게이트와 Terminal에서 `dkssudgktpdy` → 안녕하세요 QEMU 실행 검증
부팅 디스크	`--disk-image`로 protective MBR, GPT, FAT32 ESP와 `EFI/BOOT/BOOTX64.EFI` 생성
UEFI	console, memory services, protocol lookup, ExitBootServices, GOP framebuffer

top-level name is value는 freestanding 정적 선언입니다. 함수에서 mutable scalar global을 바꾸려면 기존 global name 문법을 사용합니다. struct Name packed do는 padding 없는 하드웨어 레이아웃을 만들고, 일반 typed struct는 필드 폭에 맞춰 자연 정렬합니다.

struct Device packed do
  vendor: u16
  command: u16
end

device_storage is static.struct(Device)
count: u64 is 0

func probe() -> u64 do
  global count
  device: ptr[Device] is device_storage
  device.command is 7
  previous is atomic.fetch_add64(addr_of(count), 1)
  return device.vendor
end

func timer(frame: ptr[Frame]) interrupt do는 error code가 없는 vector용이고 interrupt_error는 CPU가 error code를 푸시하는 vector용입니다. cpu.idt_set_gate는 direct handler address와 vector의 error-code ABI를 컴파일 때 검사합니다. 생성된 wrapper는 saved CS가 ring 3일 때 SWAPGS를 실행하고 LFENCE로 결정을 직렬화합니다. TSS RSP/IST와 descriptor 생성, LTR, FXSAVE/XSAVE, XSETBV도 지원하지만 실제 per-CPU 할당, FPU/SIMD 저장, NMI-safe entry 정책은 kernel이 정해야 합니다.

Sura freestanding 기반에는 메모리·프로세스·syscall·IPC, SHA-256·SHA-384·AES-128-GCM·X25519·RSA/X.509·TLS 1.3, PCI·ACPI·AHCI·NVMe·xHCI·VirtIO·HDA, SuraFS·FAT32·VFS, IPv4·DHCP·DNS·TCP·HTTP, PNG·JPEG·HTML·CSS·제한된 JavaScript/WebAssembly, framebuffer·창 관리자와 기본 데스크톱 앱이 구현되어 있습니다. 전체 QEMU 데스크톱 gate는 suralang.site의 직접 HTTPS 선택, 인증서 체인·호스트명·시간과 여섯 개의 pinned root(ISRG Root X1, DigiCert Global Root G2, GlobalSign Root CA - R3, Amazon Root CA 1, USERTrust RSA Certification Authority, Microsoft RSA Root Certificate Authority 2017) 중 일치하는 신뢰점 검증, 암호화 응답, 외부 CSS, DOM/box painting과 PNG 처리를 실행합니다. 주소창 DNS, 첫 TCP 연결, 첫 TLS handshake는 데스크톱 루프에서 점진적으로 진행되며 입력과 취소를 처리합니다. 이후 응답 수신·decode, 추가 리소스 TLS 연결, DOM·layout·rendering은 아직 동기식 ring 0 경로지만 입력을 협력적으로 처리하고 F6 취소로 안전하게 풀립니다. IPv6, 완전한 TCP 재전송·혼잡 제어·out-of-order reassembly, 범용 TLS 알고리즘과 운영체제급 루트 저장소, 인증서 폐기 확인·세션 재개, 완전한 CSS·JavaScript·Web API, GPU 가속, SMP load balancing, complete per-AP lifecycle, FPU/SIMD process state와 ARM64 backend는 아직 없습니다. 자세한 compile-only·executed 구분은 Guide/OS_DEVELOPMENT.md와 machine-readable data에 있습니다.

빌드와 배포

출력	내용
`.sura.bc`	`--compile`이 만드는 SURB v3 register bytecode; 1.11.1 runtime은 v2와 v3를 읽음
`.sura.srp`	release container v5: register bytecode·literal·constant payload, randomized nonce, integrity seal
protected metadata	line/local/function/parameter debug name 제거; optional release id·expiry
runtime symbol	class name, method map key, global name, constant은 실행에 필요한 형태로 package에 남음
접근 값	`--release-key`, `--release-license`와 실행 시 대응 load option 또는 environment value
launcher	`surapkg protect --exe`가 embedded package와 engine locator를 포함한 Windows launcher 생성; 실행 시 옆의 Sura engine 또는 `SURA_ENGINE` 경로 사용
검사	package/launcher에서 source text, source line, string literal, key/license byte pattern scan

payload transform과 seal은 Sura release container의 자체 형식입니다. 동일 source도 randomized nonce 때문에 package byte가 달라지고 seal 검사는 변조된 payload를 실행 전에 거부합니다.

leak scan은 16..65536 byte source 전체, 16 byte 이상 non-comment source line, 4 byte 이상 string literal, 4 byte 이상 key/license byte를 package와 launcher에서 검색합니다. protect-verify가 report target과 hash를 재검증합니다.

sura --compile app.sura --out app.sura.bc
sura --release app.sura --out app.sura.srp
sura --load-release app.sura.srp
surapkg protect . --exe
surapkg protect-verify dist/protect-report.json --json verify.json

성능과 검증 기록

검증	결과
core suite	107/107 PASS; 107/107 PASS
release evidence	156/157 · incomplete
goal audit	126/127 · 99.2% · INCOMPLETE
target lowering	JS full 41, ignored 2; WASM full 27, partial 14, ignored 2
bytecode validation	not rerun as a standalone suite; stable VM/JIT suites PASS
JIT safety	stable suite의 frame·upvalue·exception regression cases PASS
FFI safety	not rerun as a standalone suite; stable VM/JIT suites PASS
async runtime concurrency	stable VM/JIT async cases PASS; dedicated async race regression retained
release payload	installer smoke verified generated kit, locked-upgrade handling, single-file installation, execution, and uninstall

검증 파일의 a735688c2f11de4e33b768c3aa2cdcfba7278e7d2d4b722d7144c6208cf10fe7 해시는 현재 SuraLanguage.exe 8518877 bytes를 식별합니다. 생성된 installer kit와 single-file 설치 흐름은 installer smoke를 통과했습니다. surapkg.exe는 5372032 bytes, SHA-256 a7640f81268b7be834d08134afdb222bb74beb507e774ccac3146e4257594cfb입니다.

최신 기록은 2026-07-17 Windows x64, 12th Gen Intel(R) Core(TM) i5-12400F, g++.exe (Rev13, Built by MSYS2 project) 15.2.0에서 같은 100,000-step inner physics loop를 Sura JIT와 C++ O3로 각각 5회 측정했습니다. Vec2는 Sura JIT 0.071 ms, C++ O3 0.050 ms, 비율 1.42×였습니다. Vec3는 Sura JIT 0.090 ms, C++ O3 0.050 ms, 비율 1.79×였습니다. 두 fair-scope 검사를 모두 통과했으며, 이 수치는 특정 물리 루프 기록이지 언어 전체 성능을 대표하지 않습니다. 측정 engine SHA-256은 70d97168df605bc68af1354c166cc5d8a509a603fed6d9ed286806830acdd80f입니다.

2026-07-13의 이전 공개 기록은 Vec2 38.33×, Vec3 105.62×였고, 2026-07-12의 더 이전 기록은 Vec2 17.225 ms, Vec3 62.254 ms였습니다. 비교 범위와 엔진이 다른 기록은 최신 수치와 섞어 해석하지 않습니다.

Guide/GPU_AND_SCALE.md에 기록된 RTX 4060 결과는 Sura 1.8, engine SHA-256 prefix 3270a9의 역사적 측정입니다. direct causal-attention forward+backward 50회 중앙값은 B1/H4/T64/D32에서 Sura 1.5076 ms, PyTorch 0.4649 ms, 비율 3.242×였고 B1/H4/T128/D64에서는 Sura 5.6562 ms, PyTorch 0.4282 ms, 비율 13.209×였습니다.

native emitter는 Win64 x64 전체 backend, Linux x86-64 System V baseline, little-endian Windows/Linux/macOS ARM64 AAPCS64 baseline을 구현합니다. 두 baseline(x86-64는 8차, ARM64는 5차 개정)은 상수·이동·정적으로 숫자임이 증명된 덧셈·뺄셈·곱셈·단항 음수·여섯 가지 비교·0이 아님이 증명된 나눗셈·가드된 전역 읽기·순수 숫자 함수 사이의 네이티브 직접 호출(재귀 포함)을 인라인으로 내보내고, 타입이 증명되지 않은 산술·비교·분기는 실행 시 NaN-box 태그를 검사해 두 피연산자가 숫자면 인라인으로 계산합니다. 배열 인덱싱(범위 검사 포함)·push·len·딕셔너리 has도 인라인이고, x86-64 baseline은 인스턴스 필드 읽기·쓰기도 사이트의 인라인 캐시(클래스·필드 번호)를 실행 시점에 읽어 인라인으로 처리하며, 문자열·딕셔너리 읽기와 쓰기·in·for ... in·일반 호출·그 밖의 메서드 호출은 17개 VM helper를 네이티브 코드에서 호출합니다. x86-64 두 tier(Win64 전체 컴파일러와 System V baseline)는 루프 레지스터 캐시를 공유합니다: 바깥에서 뛰어드는 분기가 없는 루프 안에서 산술이 읽고 쓰는 레지스터는 XMM 레지스터에도 상주하고(Win64는 callee-saved XMM6–XMM15를 프롤로그에서 저장하고 UNWIND_INFO에 기록, System V는 호출 뒤 재적재), baseline은 모든 정의가 메모리 슬롯도 함께 쓰므로(store-through) helper·GC·deopt·예외가 항상 최신 메모리를 보고, Win64 전체 컴파일러는 캐시가 직접 내보내는 연산(상수·이동·산술·비교·나눗셈·나머지·배열 인덱싱·인라인 push/len/has·가상 레코드 접근·분기)만으로 된 루프에서는 XMM에만 두고(write-back) helper 호출 직전과 루프를 벗어나는 경로(조건 탈출은 exit stub)에서만 되씁니다. 전체 컴파일러는 결과가 바로 뒤 조건분기에만 쓰이는 비교를 플래그 분기로 융합하고, 나눗셈(제수 0·NaN은 helper)과 정수값 나머지(idiv, 그 외 fmod helper)를 인라인으로 내보내며, 클로저의 숫자로 쓰이는 매개변수는 진입에서 한 번 검사해 숫자가 아니면 deopt sentinel로 인터프리터에 넘깁니다(인터프리터가 이미 숫자 아님을 본 매개변수는 가드하지 않음). 두 x86-64 tier 모두 순서 비교를 바로 뒤 조건분기와 융합하고, baseline의 자기 재귀 직접 호출은 콜리가 쓰기 전에 읽을 수 있는 프레임 슬롯만 0으로 채웁니다. 전체 컴파일러는 INDEX_GET/SET의 키·hoist된 컨테이너로만 쓰이는 MOVE 임시를 접어 원본 레지스터를 읽고, 함수 안 전역 읽기는 범위·nil 검사 뒤 인라인입니다. 딕셔너리는 마지막으로 조회한 문자열 키 객체와 그 슬롯을 기억해(삭제·재구성 시 무효) 같은 키의 has·읽기·쓰기가 한 번만 탐사합니다. 숫자 태그 검사는 두 tier 모두 unordered 자기 비교(ucomisd x,x; jp) 두 명령으로 하며(NaN-box 태그는 모두 NaN 패턴, 진짜 NaN 숫자는 정확한 slow path), 순수 baseline 본문은 가드된 전역을 진입에서 한 번만 검사하고 본문 안에서는 단순 로드합니다. 메서드 호출이 없어 배열 크기가 변할 수 없는 write-back 루프에서는 끌어올린 컨테이너의 data 포인터를 GPR에, 끝 포인터를 프레임 슬롯에 두어 원소 접근이 lea 하나와 비교 하나로 줄어듭니다. 산술(+ - * /)은 먼저 계산하고 결과가 NaN인지 한 번만 검사합니다: NaN 박싱된 비숫자는 모두 NaN 패턴이라 연산을 통과하면 결과도 NaN이 되므로, 결과가 NaN이 아니면 두 피연산자가 모두 숫자였음이 증명됩니다. 진짜 NaN 결과(NaN 피연산자, 무한대끼리 빼기, 0 곱하기 무한대)도 문자열이나 객체와 같은 느린 경로로 가서 인터프리터와 똑같은 값을 냅니다. 순서·동등 비교는 ucomisd가 내는 unordered 플래그만 보면 되므로 태그 검사가 없고, 나머지 연산은 정수 왕복 검사가 이미 NaN을 걸러냅니다. 끌어올린 컨테이너는 접근마다 널 검사를 하지 않습니다(프리헤더가 배열이 아니면 끝 포인터도 0으로 두고 빈 벡터는 끝이 데이터와 같아, 범위 비교가 모든 인덱스를 걸러냅니다). 바로 뒤 명령만 읽고 그 뒤로 죽는 숫자 상수는 프레임 슬롯에 쓰지 않고 소비하는 산술·비교가 상수 배열에서 직접 읽습니다(소비자가 helper로 빠질 수 있으면 피연산자를 프레임에서 읽으므로 접지 않습니다). 루프 안 모든 접근이 같은 키를 쓰고 그 키가 정수 step으로만, 그리고 모든 접근보다 뒤에서 한 번만 늘어나면, 끌어올린 레지스터가 배열 시작 대신 원소 포인터를 듭니다: 프리헤더가 data + trunc(키)*8로 채우고 반복마다 step*8을 더하므로 접근은 경계 비교와 이동뿐입니다. 키가 [0, 2^31)의 정수가 아니면 포인터를 끝에 두어 그 루프의 모든 접근이 helper로 가고, 음수 인덱스는 인터프리터처럼 뒤에서부터 셉니다. 치환된 생성자는 호출 대상 레지스터를 읽지 않으므로 그 값만 적재하던 전역 읽기(클래스 이름이면 매번 helper)는 내보내지 않고, 치환 계획이 값이 읽히지 않음을 보장하는 레코드 별칭 복사와 결과 레지스터 쓰기도 생략합니다. 바로 앞 명령으로 알려진 2의 거듭제곱 상수로 나누기는 정확한 역수 곱하기(비트 단위로 같은 결과, 0 검사 없음)로, 그 나머지는 음이 아닌 정수 피제수의 하위 비트로 계산하고 나머지 경우는 helper의 fmod가 맡습니다. 루프가 쓰지 않는 배열 컨테이너(컴파일러가 그것을 복사해 넣는 임시 레지스터 포함)의 ‘배열인가’ 검사는 pre-header에서 한 번만 하고 GCArray*(배열이 아니면 0)를 callee-saved GPR(R14·R15, 전체 컴파일러는 RSI·RDI까지)에 두며, 각 접근은 null 검사·인덱스 변환·경계 검사만 합니다. 원소 포인터와 길이는 매 접근마다 다시 읽으므로 루프 안 push도 안전하고, 헤더로 들어오는 바깥 분기는 pre-header로 우회합니다. Win64 전체 컴파일러의 숫자 증명은 배열·호출·객체 명령을 만나도 유지되며(그 명령이 쓰는 레지스터만 미지수로 둠) 숫자 동등 비교도 인라인입니다. 루프 안에서 plain 생성자로 만들어 필드 읽기·쓰기로만 쓰고 루프 밖으로 나가지 않는 레코드는 할당하지 않고 필드를 프레임 슬롯에 둡니다(배열에 담기거나 호출에 넘겨지거나 루프 뒤에 읽히면 그대로 할당). helper가 예외를 내면 그 명령에서 register VM으로 되돌아가 VM과 같은 오류를 냅니다. 네이티브 직접 호출은 callee가 helper에 닿을 수 있을 때만 프레임을 VM 값 스택에 올리고(하이브리드 프레임), fib처럼 helper에 닿지 않는 callee는 기계 스택을 씁니다. Windows x64는 호출이 있는 순수 숫자 함수(fib 같은 재귀)만 baseline으로 보내고, 호출 없는 루프 본문을 포함한 나머지는 인라인 캐시를 가진 전체 컴파일러가 맡습니다. array.sort는 모든 원소가 숫자면 IEEE 비트 패턴 기수 정렬(같은 바이트 패스 생략)이고, 모듈 함수 호출(string.len 등)은 호출 사이트가 (모듈 사전, 함수) 쌍을 캐시합니다. macOS x86-64에는 native backend가 없습니다. Vec2/Vec3 benchmark의 strict counted-loop shortcut은 인식된 top-level loop, closure identity, 정확한 field-copy constructor, Vec2/Vec3 layout, add/scale/cross와 step/step3 bytecode graph, numeric input, escape·non-alias 조건을 모두 증명한 경우에만 사용합니다. 하나라도 맞지 않으면 원래 VM/native bytecode path로 실행합니다. 한 번 이상 반복한 shortcut은 원래 position을 변경하지 않고 fresh result instance를 저장하므로 원래 객체를 가리키는 alias의 field가 바뀌지 않으며, 0회 반복은 원래 identity를 유지합니다. 이 경로는 일반 사용자 loop 최적화가 아닙니다. 일반 control-flow deoptimization, 범용 escape analysis, 루프 레지스터 캐시를 넘어서는 범용 register allocation, loop-invariant code motion(배열 컨테이너 검사 밖의 가드 끌어올리기 포함)은 구현되지 않았습니다. Windows x64 native helper frame은 UNWIND_INFO를 등록합니다.

구조화 데이터

이 HTML의 script#sura-reference-data[type="application/json"]에 version, compatibility contract와 support tier, runtime contract, 기본값 평가, syntax, truthiness, stdlib catalog, 34개 module의 528개 signature, async, target 차이, external dependency, release artifact hash·signing·license, performance record, verification과 CLI help를 JSON으로 포함합니다.

각 module API entry는 이름, 호출 signature와 source 위치를 제공합니다. 공통 runtime 제한과 async·FFI·release·target 계약은 이 문서의 prose와 같은 JSON object에 기록합니다.

optional parameter는 signature에서 [name], variadic parameter는 ...로 표시합니다. 호출 이름과 argument 수는 각 signature를 기준으로 사용합니다.

구조화 데이터 보기

{
  "schema": "sura.public.reference.v1",
  "language": "Sura",
  "version": "1.11.1",
  "published_date": "2026-07-17",
  "source_extension": ".sura",
  "package_manifest": "sura.pkg.json",
  "compatibility": {
    "schema": "sura.compatibility.v1",
    "language_version": "1.11.1",
    "stable_series": "1.11",
    "baseline_created": "2026-07-16",
    "source": {
      "guarantee_starts_at": "1.11.1",
      "patch_release_breaking_changes": "forbidden",
      "minor_release_deprecation_period": 1,
      "fixtures": [
        {
          "path": "tests/compat/1.11/core.sura",
          "marker": "compat-1.11-core: PASS"
        },
        {
          "path": "tests/compat/1.11/objects.sura",
          "marker": "compat-1.11-objects: PASS"
        },
        {
          "path": "tests/compat/1.11/stdlib.sura",
          "marker": "compat-1.11-stdlib: PASS"
        }
      ],
      "historical_probes": [
        {
          "series": "1.10",
          "runtime_version": "1.10.0",
          "status": "verification_only",
          "platform": "windows-x64",
          "archive": "tests/compat/SuraLanguage-1.10.0-windows-x64.zip",
          "archive_entry": "payload/SuraLanguage.exe",
          "release_manifest": "tests/compat/release-1.10.0.json",
          "verification_manifest": "tests/compat/verification-1.10.0.json",
          "bytecode_fixture": "tests/compat/1.10/core.sura",
          "fixtures": [
            {
              "path": "tests/compat/1.10/core.sura",
              "marker": "compat-1.10-core: PASS"
            },
            {
              "path": "tests/compat/1.10/objects.sura",
              "marker": "compat-1.10-objects: PASS"
            },
            {
              "path": "tests/compat/1.10/stdlib.sura",
              "marker": "compat-1.10-stdlib: PASS"
            }
          ]
        }
      ]
    },
    "support": {
      "policy_effective": "2026-07-16",
      "minimum_maintenance_months": 12,
      "minimum_maintenance_until": "2027-07-16",
      "next_minor_overlap_months": 6,
      "source_compatibility_major": 1,
      "stable_series": [
        {
          "series": "1.11",
          "status": "active",
          "first_supported_patch": "1.11.1",
          "maintenance_not_before": "2027-07-16"
        }
      ]
    },
    "deprecations": [],
    "stable_api": {
      "snapshot": "tests/compat/1.11/stable-api.json",
      "modules": [
        "array",
        "dict",
        "fs",
        "json",
        "string",
        "test"
      ],
      "removal_without_deprecation": "forbidden",
      "signature_change_without_deprecation": "forbidden"
    },
    "bytecode": {
      "current": 3,
      "accepted": [
        2,
        3
      ]
    },
    "release_package": {
      "current": 5,
      "accepted": [
        1,
        2,
        3,
        4,
        5
      ]
    },
    "plugin_abi": "1.1.0",
    "ffi_abi": "1.2.0",
    "support_tiers": {
      "stable": [
        "native Sura syntax and register VM",
        "core values, control flow, functions, classes, and exceptions",
        "file, string, array, dictionary, JSON, and test APIs",
        "surapkg project creation, run, test, and lock file",
        "C FFI and versioned plugin ABI"
      ],
      "platform_limited": [
        "native JIT on Win64 x86-64 for supported opcodes and functions, plus exception-free straight-line baselines on Linux x86-64 and little-endian Windows/Linux/macOS ARM64 for constants, moves, proven-numeric addition, subtraction, multiplication, unary negation, six comparisons, and division by a proven nonzero divisor",
        "CUDA resident operations on compatible NVIDIA systems",
        "media operations when FFmpeg is installed or explicitly configured",
        "Windows installer and Microsoft Store package for Windows x64"
      ],
      "experimental": [
        "JavaScript and WebAssembly translation targets",
        "Transformer extensions and distributed training",
        "bounded byte-level BPE tokenizer and its version 2 tokenizer file",
        "bounded CPU ONNX opset 7 through 18 graph execution subset",
        "advanced protected-release policies and external registry operations"
      ]
    }
  },
  "project_governance": {
    "scope_policy": "SCOPE.md",
    "contribution_guide": "CONTRIBUTING.md",
    "new_public_surface_default": "experimental",
    "stable_promotion_requires": [
      "declared platforms and external dependencies",
      "tested success, failure, and fallback behavior",
      "current-syntax examples and public reference",
      "recorded source, bytecode, package-format, and ABI impact",
      "applicable Windows and cross-platform CI coverage"
    ]
  },
  "execution": {
    "pipeline": [
      "lexer",
      "parser/AST",
      "strict type checker",
      "register bytecode compiler",
      "register VM"
    ],
    "bytecode": {
      "writes_version": 3,
      "reads_versions": [
        2,
        3
      ],
      "magic": "SURB"
    },
    "optional_native_jit": {
      "flag": "--jit",
      "platform_abi": "Windows x64 / Win64, Linux x86-64 / System V, and little-endian Windows/Linux/macOS ARM64 / AAPCS64 baseline",
      "emitter_backend": "x64-win64 full compiler with baseline-first pure numeric functions; x64-sysv-baseline and arm64-aapcs-baseline helper-calling baselines (revision 4) with hybrid frames",
      "backends": [
        {
          "os": "windows",
          "architecture": "x86-64",
          "abi": "win64",
          "backend": "x64-win64",
          "scope": "pure numeric functions go to the baseline first; everything else uses the full compiler with inline caches, helpers, and guarded optimization paths"
        },
        {
          "os": "linux",
          "architecture": "x86-64",
          "abi": "sysv-x86-64",
          "backend": "x64-sysv-baseline",
          "scope": "inline constants, moves, statically proven numeric + - *, unary -, the six comparisons, proven non-zero /, guarded global reads, and native direct calls between pure numeric functions including recursion; arrays, strings, dicts, field access, in, for...in, general calls, and method calls run through VM helpers; a helper exception deopts to the register VM at that instruction"
        },
        {
          "os": "windows/linux/macos",
          "architecture": "arm64",
          "abi": "aapcs64",
          "backend": "arm64-aapcs-baseline",
          "scope": "little-endian; same scope as x64-sysv-baseline, verified by unit tests on ARM64 CI runners and instruction-level unicorn emulation"
        }
      ],
      "baseline_helpers": [
        "sura_bl_arith",
        "sura_bl_call",
        "sura_bl_call_builtin",
        "sura_bl_dict_keys",
        "sura_bl_dot_get",
        "sura_bl_dot_set",
        "sura_bl_foreach_next",
        "sura_bl_index_get",
        "sura_bl_index_set",
        "sura_bl_load_global",
        "sura_bl_make_array",
        "sura_bl_make_dict",
        "sura_bl_method_call",
        "sura_bl_op_in",
        "sura_bl_print",
        "sura_bl_store_global",
        "sura_bl_truthy"
      ],
      "hybrid_frames": "a native direct call places the callee frame on the VM value stack only when the callee can reach a helper, so the collector sees it; helper-free callees such as fib keep the machine stack",
      "mode": "lazy partial compilation inside the register VM",
      "warmup_thresholds": {
        "function_calls": 6,
        "method_calls": 5
      },
      "fallback": "unsupported or failed native compilation continues in the register VM",
      "strict_vector_loop_shortcut": {
        "scope": "recognized top-level counted loops calling canonical 2D/3D vector updates; source class and function names are arbitrary",
        "proof": "x/y(/z) layout, closure identity, field-copy constructor, exact add/scale/cross and update bytecode graphs, numeric inputs, and escape/non-alias guards",
        "result_identity": "one or more iterations store a fresh result instance; zero iterations preserve the original instance",
        "fallback": "any compile-time proof or runtime guard mismatch executes the original VM/native bytecode path"
      }
    },
    "value_representation": "NaN-boxed dynamic Value",
    "garbage_collector": "mark-sweep; process-global heap; per-type free-list pools for strings, arrays, dictionaries and instances; allocation takes the runtime mutex only once an embedded context exists",
    "diagnostics_default": "English",
    "diagnostics_korean": "--lang ko or SURA_LANG=ko",
    "strict_types_default": true,
    "type_system": "strict-by-default gradual type checker",
    "legacy_source_flag": "--legacy-types",
    "legacy_disallowed_for": [
      "--compile",
      "--release"
    ]
  },
  "syntax": {
    "lexical": {
      "encoding": "UTF-8; optional UTF-8 BOM is accepted",
      "line_comments": [
        "#",
        "//"
      ],
      "strings": "double quoted; supported escapes are \\n, \\r, \\t, \\\", and \\\\",
      "interpolation": "{expression} inside a double-quoted string",
      "statement_separator": "newline"
    },
    "declaration": "name is value",
    "typed_declaration": "name: type is value",
    "function": "func name(params) do ... end",
    "default_parameter": [
      "name is value",
      "name: type is value"
    ],
    "default_evaluation": {
      "trigger": "only when the positional argument is omitted",
      "explicit_nil": "passed unchanged",
      "order": "left to right",
      "visible_bindings": "earlier parameters; methods also expose self",
      "supported_forms": [
        "named function",
        "anonymous function",
        "lambda",
        "method",
        "class field",
        "struct field"
      ],
      "class_fields": "evaluated for each new instance in parent-to-child declaration order",
      "automatic_struct_fields": "evaluated for each omitted constructor argument; explicit arguments skip the field expression"
    },
    "lambda": "|params| expression; || expression",
    "blocks": [
      "if/elif/else/end",
      "while/do/end",
      "repeat/do/end",
      "for/do/end"
    ],
    "object_forms": [
      "class",
      "extends",
      "new",
      "self",
      "super",
      "struct",
      "enum"
    ],
    "errors": [
      "try",
      "catch",
      "finally do",
      "throw"
    ],
    "optional_access": "value?.field",
    "null_coalescing": "left ?? right",
    "ternary": "condition ? then_value : else_value",
    "module_import": [
      "use module",
      "import \"path.sura\""
    ],
    "operator_precedence_low_to_high": [
      {
        "operators": [
          "??"
        ],
        "associativity": "right"
      },
      {
        "operators": [
          "? :"
        ],
        "associativity": "right"
      },
      {
        "operators": [
          "or"
        ],
        "associativity": "left; short-circuit and returns the selected operand"
      },
      {
        "operators": [
          "and"
        ],
        "associativity": "left; short-circuit and returns the selected operand"
      },
      {
        "operators": [
          "not"
        ],
        "associativity": "prefix"
      },
      {
        "operators": [
          "==",
          "!=",
          "<",
          "<=",
          ">",
          ">=",
          "in"
        ],
        "associativity": "one comparison per unparenthesized expression"
      },
      {
        "operators": [
          "|"
        ],
        "associativity": "left"
      },
      {
        "operators": [
          "^"
        ],
        "associativity": "left"
      },
      {
        "operators": [
          "&"
        ],
        "associativity": "left"
      },
      {
        "operators": [
          "<<",
          ">>"
        ],
        "associativity": "left"
      },
      {
        "operators": [
          "+",
          "-"
        ],
        "associativity": "left"
      },
      {
        "operators": [
          "*",
          "/",
          "%"
        ],
        "associativity": "left"
      },
      {
        "operators": [
          "unary -",
          "~"
        ],
        "associativity": "prefix"
      },
      {
        "operators": [
          "call",
          "index",
          ".",
          "?."
        ],
        "associativity": "postfix"
      }
    ],
    "evaluation_order": {
      "call_arguments": "left to right",
      "array_elements": "left to right",
      "dictionary_values": "source key order",
      "null_coalescing": "right side runs only when the left side is nil",
      "ternary": "only the selected branch runs"
    }
  },
  "truthiness": {
    "false_values": [
      "nil",
      "false",
      "number 0",
      "empty string",
      "empty array",
      "empty dict"
    ],
    "true_values": [
      "non-zero number",
      "non-empty string",
      "non-empty array",
      "non-empty dict",
      "functions",
      "instances",
      "tensors"
    ]
  },
  "bitwise_contract": {
    "operand": "finite integral number in [-9007199254740991, 9007199254740991]",
    "shift_count": "integer 0..63",
    "left_shift_result": "safe integer range",
    "right_shift": "arithmetic floor division by 2^count"
  },
  "stdlib": {
    "package_inventory_entry_count": 39,
    "runtime_module_namespace_count": 35,
    "catalogued_runtime_module_count": 34,
    "api_signature_count": 528,
    "global_builtin_name_and_alias_count": 664,
    "global_builtin_names_and_aliases": [
      "Error",
      "abs",
      "append_file",
      "argc",
      "argv",
      "array_avg",
      "array_chunk",
      "array_count_by",
      "array_flatten",
      "array_group_by",
      "array_len",
      "array_length",
      "array_max",
      "array_min",
      "array_pluck",
      "array_range",
      "array_repeat",
      "array_size",
      "array_sort_by",
      "array_sum",
      "array_unique",
      "array_zip",
      "assert",
      "assert_approx",
      "assert_between",
      "assert_contains",
      "assert_eq",
      "assert_len",
      "assert_match",
      "assert_ne",
      "assert_neq",
      "assert_not_contains",
      "assert_type",
      "async_all",
      "async_all_timeout",
      "async_any",
      "async_await",
      "async_await_timeout",
      "async_cancel",
      "async_cancelled",
      "async_cleanup",
      "async_cmd",
      "async_configure",
      "async_forget",
      "async_http_get",
      "async_http_request",
      "async_limits",
      "async_pending",
      "async_ready",
      "async_ready_all",
      "async_scope_attach",
      "async_scope_cancel",
      "async_scope_close",
      "async_scope_join",
      "async_scope_open",
      "async_scope_status",
      "async_sleep",
      "async_status",
      "async_sura",
      "auth_basic",
      "auth_bearer",
      "autograd_adam",
      "autograd_add",
      "autograd_all_reduce_gradients",
      "autograd_autocast",
      "autograd_backward",
      "autograd_backward_scaled",
      "autograd_bce",
      "autograd_bce_logits",
      "autograd_cast",
      "autograd_causal_attention",
      "autograd_clip_grad_norm",
      "autograd_cross_entropy",
      "autograd_cross_entropy_ids",
      "autograd_cuda_available",
      "autograd_cuda_info",
      "autograd_cuda_reset_stats",
      "autograd_cuda_stats",
      "autograd_cuda_synchronize",
      "autograd_data",
      "autograd_detach",
      "autograd_device",
      "autograd_div",
      "autograd_dtype",
      "autograd_embedding",
      "autograd_gelu",
      "autograd_grad",
      "autograd_grad_info",
      "autograd_grad_norm",
      "autograd_item",
      "autograd_layer_norm",
      "autograd_limits",
      "autograd_linear",
      "autograd_load_checkpoint",
      "autograd_load_onnx_weights",
      "autograd_load_safetensors",
      "autograd_matmul",
      "autograd_mean",
      "autograd_mse",
      "autograd_mul",
      "autograd_neg",
      "autograd_numel",
      "autograd_ones",
      "autograd_parameter",
      "autograd_randn",
      "autograd_relu",
      "autograd_requires_grad",
      "autograd_reset_optimizer",
      "autograd_reshape",
      "autograd_run_onnx",
      "autograd_save_checkpoint",
      "autograd_save_onnx_weights",
      "autograd_save_safetensors",
      "autograd_set_requires_grad",
      "autograd_sgd",
      "autograd_shape",
      "autograd_sigmoid",
      "autograd_softmax",
      "autograd_storage_bytes",
      "autograd_sub",
      "autograd_sum",
      "autograd_tanh",
      "autograd_tensor",
      "autograd_to",
      "autograd_transpose",
      "autograd_unscale_gradients",
      "autograd_zero_grad",
      "autograd_zeros",
      "await",
      "await_all",
      "await_all_timeout",
      "await_any",
      "await_timeout",
      "base64_decode",
      "base64_encode",
      "base64_url_decode",
      "base64_url_encode",
      "camera_project",
      "ceil",
      "check",
      "check_eq",
      "check_match",
      "clamp",
      "cli_parse",
      "clock",
      "clone",
      "cls",
      "cmd_exists",
      "cmd_join",
      "cmd_quote",
      "cmd_run",
      "cmd_run_checked",
      "command_exists",
      "concat",
      "console_assert",
      "console_beep",
      "console_clear",
      "console_color",
      "console_colour",
      "console_count",
      "console_count_reset",
      "console_debug",
      "console_dir",
      "console_dirxml",
      "console_error",
      "console_exception",
      "console_flush",
      "console_group",
      "console_group_collapsed",
      "console_group_end",
      "console_height",
      "console_hrtime",
      "console_info",
      "console_input",
      "console_inspect",
      "console_is_tty",
      "console_json",
      "console_line",
      "console_log",
      "console_print",
      "console_println",
      "console_profile",
      "console_profile_end",
      "console_prompt",
      "console_raw",
      "console_readLine",
      "console_read_line",
      "console_readline",
      "console_reset_color",
      "console_reset_colour",
      "console_set_color",
      "console_set_colour",
      "console_size",
      "console_status",
      "console_strip_ansi",
      "console_style",
      "console_table",
      "console_time",
      "console_time_end",
      "console_time_log",
      "console_time_stamp",
      "console_trace",
      "console_warn",
      "console_warning",
      "console_width",
      "console_write",
      "console_write_line",
      "console_writeln",
      "constant_time_eq",
      "contains",
      "cookie_build",
      "cookie_get",
      "cookie_parse",
      "copy_file",
      "cos",
      "count_by",
      "crypto_constant_time_eq",
      "crypto_random_bytes",
      "crypto_random_hex",
      "csv_parse",
      "csv_stringify",
      "cwd",
      "dataset_close",
      "dataset_info",
      "dataset_next",
      "dataset_open",
      "dataset_pack_text",
      "dataset_reset",
      "datetime_add",
      "datetime_diff",
      "datetime_format",
      "datetime_now",
      "datetime_parse",
      "datetime_parts",
      "datetime_utc_format",
      "db_all",
      "db_count",
      "db_delete",
      "db_find",
      "db_get",
      "db_has",
      "db_insert",
      "db_keys",
      "db_query",
      "db_remove",
      "db_set",
      "db_update",
      "delete_file",
      "deserialize",
      "dict_get_path",
      "dict_items",
      "dict_keys",
      "dict_merge",
      "dict_omit",
      "dict_pick",
      "dict_values",
      "embedding_search",
      "endsWith",
      "env_get",
      "env_load",
      "env_require",
      "env_set",
      "exists",
      "ffi_call",
      "ffi_load",
      "file_append",
      "file_copy",
      "file_delete",
      "file_exists",
      "file_glob",
      "file_hmac_sha256",
      "file_info",
      "file_is_dir",
      "file_is_file",
      "file_lines",
      "file_list",
      "file_move",
      "file_read",
      "file_read_bytes",
      "file_read_json",
      "file_remove_tree",
      "file_sha256",
      "file_size",
      "file_walk",
      "file_write",
      "file_write_bytes",
      "file_write_json",
      "floor",
      "form_build",
      "form_parse",
      "glob_files",
      "grid_clear",
      "grid_draw",
      "grid_init",
      "grid_set",
      "group_by",
      "headers_get",
      "headers_has",
      "headers_merge",
      "headers_redact",
      "hex_decode",
      "hex_encode",
      "hmac_sha256",
      "hmac_sha256_file",
      "home_dir",
      "http_backoff_delays",
      "http_charset",
      "http_content_type",
      "http_get",
      "http_is_json",
      "http_json",
      "http_post",
      "http_request",
      "http_request_full",
      "http_request_json",
      "http_request_json_checked",
      "http_request_retry",
      "http_request_retry_json",
      "http_request_retry_json_checked",
      "http_retry_after",
      "http_serve_routes",
      "http_serve_static",
      "http_server_stop",
      "http_server_url",
      "http_status_ok",
      "http_status_retryable",
      "http_status_text",
      "indexOf",
      "ini_parse",
      "ini_stringify",
      "input",
      "is_dir",
      "is_file",
      "is_windows",
      "join",
      "json_delete_path",
      "json_has_path",
      "json_merge_patch",
      "json_parse",
      "json_path",
      "json_pretty",
      "json_set_path",
      "json_stringify",
      "json_try_parse",
      "jsonl_parse",
      "jsonl_stringify",
      "key_down",
      "length",
      "list_dir",
      "llm_budget",
      "llm_chat",
      "llm_chat_request",
      "llm_cost",
      "llm_extract_json",
      "llm_extract_text",
      "llm_message",
      "llm_messages",
      "llm_next_messages",
      "llm_next_request",
      "llm_next_request_json",
      "llm_next_schema_request",
      "llm_next_schema_request_json",
      "llm_request",
      "llm_request_json",
      "llm_request_schema",
      "llm_request_schema_json",
      "llm_request_tools",
      "llm_request_tools_json",
      "llm_request_tools_schema",
      "llm_request_tools_schema_json",
      "llm_response_schema",
      "llm_run_tools",
      "llm_stream_text",
      "llm_tool_calls",
      "llm_tool_result",
      "llm_tool_schemas",
      "llm_tools",
      "llm_usage",
      "log_debug",
      "log_error",
      "log_event",
      "log_get_level",
      "log_info",
      "log_level",
      "log_set_file",
      "log_set_json",
      "log_set_level",
      "log_warn",
      "lower",
      "mat4_identity",
      "mat4_mul",
      "mat4_rotate_y",
      "mat4_scale",
      "mat4_translate",
      "max",
      "media_ascii_frames",
      "media_available",
      "media_ffmpeg_available",
      "media_frame_to_text",
      "media_video_text_frames",
      "media_video_to_text",
      "mesh_bounds",
      "mesh_cube",
      "mesh_face_normals",
      "mesh_transform4",
      "min",
      "mkdir",
      "mouse_down",
      "mouse_pos",
      "mouse_x",
      "mouse_y",
      "move_file",
      "nn_classify",
      "nn_evaluate",
      "nn_fit_standardizer",
      "nn_forward",
      "nn_load",
      "nn_mlp",
      "nn_one_hot",
      "nn_predict",
      "nn_save",
      "nn_split",
      "nn_standardize",
      "nn_summary",
      "nn_train",
      "os_name",
      "path_abs",
      "path_basename",
      "path_dirname",
      "path_ext",
      "path_join",
      "path_normalize",
      "path_relative",
      "path_separator",
      "path_stem",
      "pluck",
      "plugin_call",
      "plugin_info",
      "plugin_load",
      "plugin_load_manifest",
      "plugin_unload",
      "pop",
      "pow",
      "pretty_json",
      "print",
      "print_n",
      "print_no_nl",
      "push",
      "python_available",
      "python_call",
      "python_call_json",
      "python_eval",
      "python_executable",
      "query_build",
      "query_parse",
      "rag_context",
      "rag_messages",
      "rag_prepare",
      "rag_sources",
      "random",
      "random_bool",
      "random_bytes",
      "random_choice",
      "random_float",
      "random_int",
      "random_seed",
      "random_shuffle",
      "read_file",
      "readkey",
      "readkey_timeout",
      "regex_capture",
      "regex_captures",
      "regex_escape",
      "regex_find_all",
      "regex_match",
      "regex_replace",
      "regex_split",
      "remove_tree",
      "replace",
      "reverse",
      "round",
      "schema_errors",
      "schema_to_json_schema",
      "schema_validate",
      "script_name",
      "secure_compare",
      "secure_random_bytes",
      "secure_random_hex",
      "serialize",
      "set_difference",
      "set_intersection",
      "set_is_subset",
      "set_is_superset",
      "set_symmetric_difference",
      "set_union",
      "sha256",
      "sha256_file",
      "sign",
      "silent",
      "sin",
      "sleep",
      "sleep_ms",
      "slice",
      "sort",
      "sort_by",
      "split",
      "sqrt",
      "sse_data",
      "sse_parse",
      "startsWith",
      "stream_avg",
      "stream_batch",
      "stream_collect",
      "stream_count",
      "stream_filter",
      "stream_from",
      "stream_join",
      "stream_lines",
      "stream_map",
      "stream_next",
      "stream_skip",
      "stream_sum",
      "stream_take",
      "stream_window",
      "string_contains",
      "string_endsWith",
      "string_ends_with",
      "string_indexOf",
      "string_index_of",
      "string_len",
      "string_length",
      "string_lines",
      "string_lower",
      "string_pad_left",
      "string_pad_right",
      "string_repeat",
      "string_replace",
      "string_size",
      "string_slice",
      "string_startsWith",
      "string_starts_with",
      "string_sub",
      "string_substring",
      "string_trim",
      "string_upper",
      "string_words",
      "substring",
      "tan",
      "task",
      "temp_dir",
      "template_render",
      "tensor_add",
      "tensor_argmax",
      "tensor_argmin",
      "tensor_clip",
      "tensor_fill",
      "tensor_flatten",
      "tensor_matmul",
      "tensor_max",
      "tensor_mean",
      "tensor_min",
      "tensor_mul",
      "tensor_shape",
      "tensor_softmax",
      "tensor_std",
      "tensor_sum",
      "tensor_transpose",
      "tensor_variance",
      "tensor_zeros",
      "tensor_zscore",
      "test_report",
      "test_summary",
      "text_chunk",
      "text_chunks",
      "timestamp",
      "to_bool",
      "to_float",
      "to_int",
      "to_str",
      "tokenizer_byte",
      "tokenizer_decode",
      "tokenizer_encode",
      "tokenizer_info",
      "tokenizer_load",
      "tokenizer_save",
      "tokenizer_train_bpe",
      "tool",
      "tool_allowed",
      "tool_call",
      "tool_call_policy",
      "tool_list",
      "tool_schema",
      "tool_spec",
      "tool_validate",
      "trim",
      "type",
      "upper",
      "url_build",
      "url_decode",
      "url_encode",
      "url_parse",
      "uuid",
      "uuid_v4",
      "vec3",
      "vec3_add",
      "vec3_angle",
      "vec3_cross",
      "vec3_distance",
      "vec3_dot",
      "vec3_lerp",
      "vec3_midpoint",
      "vec3_neg",
      "vec3_norm",
      "vec3_normalize",
      "vec3_project",
      "vec3_reflect",
      "vec3_reject",
      "vec3_scale",
      "vec3_sub",
      "vec3_transform4",
      "vec_add",
      "vec_cosine",
      "vec_dot",
      "vec_norm",
      "vec_normalize",
      "vec_scale",
      "vector3",
      "vector3_add",
      "vector3_angle",
      "vector3_cross",
      "vector3_distance",
      "vector3_dot",
      "vector3_lerp",
      "vector3_midpoint",
      "vector3_neg",
      "vector3_norm",
      "vector3_normalize",
      "vector3_project",
      "vector3_reflect",
      "vector3_reject",
      "vector3_scale",
      "vector3_sub",
      "vector3_transform4",
      "vector_add",
      "vector_cosine",
      "vector_dot",
      "vector_norm",
      "vector_normalize",
      "vector_scale",
      "vector_search",
      "wait",
      "walk_files",
      "which",
      "win_circle",
      "win_clear",
      "win_close",
      "win_focus",
      "win_init",
      "win_line",
      "win_poll",
      "win_rect",
      "win_text",
      "win_update",
      "write_file"
    ],
    "inventory_only_entries": {
      "data": "alias of json",
      "time": "alias of datetime",
      "web": "alias of http",
      "game": "package inventory source file; no VM use-module namespace",
      "system": "package inventory source file; no VM use-module namespace"
    },
    "runtime_module_aliases": {
      "data": "json",
      "time": "datetime",
      "web": "http",
      "logging": "log",
      "filesystem": "fs",
      "file": "fs",
      "testing": "test",
      "rng": "random",
      "py": "python",
      "g3d": "graphics3d",
      "graphics": "graphics3d",
      "ai": "nn"
    },
    "console_runtime_module_catalogued_by_surapkg": false,
    "console_methods": [
      "log",
      "print",
      "write",
      "write_line",
      "writeln",
      "println",
      "line",
      "info",
      "debug",
      "warn",
      "warning",
      "error",
      "exception",
      "raw",
      "flush",
      "json",
      "inspect",
      "hrtime",
      "beep",
      "clear",
      "assert",
      "time",
      "time_end",
      "timeEnd",
      "time_log",
      "timeLog",
      "time_stamp",
      "timeStamp",
      "count",
      "count_reset",
      "countReset",
      "table",
      "dir",
      "dirxml",
      "trace",
      "group",
      "group_collapsed",
      "groupCollapsed",
      "group_end",
      "groupEnd",
      "profile",
      "profile_end",
      "profileEnd",
      "style",
      "color",
      "colour",
      "strip_ansi",
      "stripAnsi",
      "set_color",
      "setColor",
      "set_colour",
      "setColour",
      "reset_color",
      "resetColor",
      "reset_colour",
      "resetColour",
      "is_tty",
      "isTTY",
      "width",
      "height",
      "size",
      "status",
      "input",
      "read_line",
      "readline",
      "readLine",
      "prompt"
    ],
    "catalog": [
      {
        "name": "array",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:array"
      },
      {
        "name": "async",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:async"
      },
      {
        "name": "autograd",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:autograd"
      },
      {
        "name": "cli",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:cli"
      },
      {
        "name": "crypto",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:crypto"
      },
      {
        "name": "data",
        "kind": "stdlib",
        "version": "",
        "path": "stdlib/data.sura"
      },
      {
        "name": "dataset",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:dataset"
      },
      {
        "name": "datetime",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:datetime"
      },
      {
        "name": "db",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:db"
      },
      {
        "name": "dict",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:dict"
      },
      {
        "name": "ffi",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:ffi"
      },
      {
        "name": "fs",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:fs"
      },
      {
        "name": "game",
        "kind": "stdlib",
        "version": "",
        "path": "stdlib/game.sura"
      },
      {
        "name": "graphics3d",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:graphics3d"
      },
      {
        "name": "http",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:http"
      },
      {
        "name": "json",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:json"
      },
      {
        "name": "llm",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:llm"
      },
      {
        "name": "log",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:log"
      },
      {
        "name": "math",
        "kind": "stdlib",
        "version": "",
        "path": "stdlib/math.sura"
      },
      {
        "name": "media",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:media"
      },
      {
        "name": "nn",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:nn"
      },
      {
        "name": "os",
        "kind": "stdlib",
        "version": "",
        "path": "stdlib/os.sura"
      },
      {
        "name": "path",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:path"
      },
      {
        "name": "plugin",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:plugin"
      },
      {
        "name": "python",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:python"
      },
      {
        "name": "rag",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:rag"
      },
      {
        "name": "random",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:random"
      },
      {
        "name": "regex",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:regex"
      },
      {
        "name": "set",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:set"
      },
      {
        "name": "stream",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:stream"
      },
      {
        "name": "string",
        "kind": "stdlib",
        "version": "",
        "path": "stdlib/string.sura"
      },
      {
        "name": "system",
        "kind": "stdlib",
        "version": "",
        "path": "stdlib/system.sura"
      },
      {
        "name": "tensor",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:tensor"
      },
      {
        "name": "test",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:test"
      },
      {
        "name": "time",
        "kind": "stdlib",
        "version": "",
        "path": "stdlib/time.sura"
      },
      {
        "name": "tokenizer",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:tokenizer"
      },
      {
        "name": "tool",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:tool"
      },
      {
        "name": "vector",
        "kind": "stdlib",
        "version": "",
        "path": "builtin:vector"
      },
      {
        "name": "web",
        "kind": "stdlib",
        "version": "",
        "path": "stdlib/web.sura"
      }
    ],
    "api_modules": [
      {
        "name": "array",
        "symbol_count": 20,
        "symbols": [
          {
            "kind": "function",
            "name": "len",
            "signature": "array.len(array)",
            "source": "builtin:array",
            "line": 1
          },
          {
            "kind": "function",
            "name": "length",
            "signature": "array.length(array)",
            "source": "builtin:array",
            "line": 2
          },
          {
            "kind": "function",
            "name": "size",
            "signature": "array.size(array)",
            "source": "builtin:array",
            "line": 3
          },
          {
            "kind": "function",
            "name": "slice",
            "signature": "array.slice(array, start, [end])",
            "source": "builtin:array",
            "line": 4
          },
          {
            "kind": "function",
            "name": "sort",
            "signature": "array.sort(array)",
            "source": "builtin:array",
            "line": 5
          },
          {
            "kind": "function",
            "name": "reverse",
            "signature": "array.reverse(array)",
            "source": "builtin:array",
            "line": 6
          },
          {
            "kind": "function",
            "name": "concat",
            "signature": "array.concat(array, ...)",
            "source": "builtin:array",
            "line": 7
          },
          {
            "kind": "function",
            "name": "push",
            "signature": "array.push(array, value, ...)",
            "source": "builtin:array",
            "line": 8
          },
          {
            "kind": "function",
            "name": "pop",
            "signature": "array.pop(array)",
            "source": "builtin:array",
            "line": 9
          },
          {
            "kind": "function",
            "name": "clone",
            "signature": "array.clone(array)",
            "source": "builtin:array",
            "line": 10
          },
          {
            "kind": "function",
            "name": "contains",
            "signature": "array.contains(array, value)",
            "source": "builtin:array",
            "line": 11
          },
          {
            "kind": "function",
            "name": "index_of",
            "signature": "array.index_of(array, value)",
            "source": "builtin:array",
            "line": 12
          },
          {
            "kind": "function",
            "name": "sum",
            "signature": "array.sum(array)",
            "source": "builtin:array",
            "line": 13
          },
          {
            "kind": "function",
            "name": "avg",
            "signature": "array.avg(array)",
            "source": "builtin:array",
            "line": 14
          },
          {
            "kind": "function",
            "name": "unique",
            "signature": "array.unique(array)",
            "source": "builtin:array",
            "line": 15
          },
          {
            "kind": "function",
            "name": "flatten",
            "signature": "array.flatten(array, [depth])",
            "source": "builtin:array",
            "line": 16
          },
          {
            "kind": "function",
            "name": "range",
            "signature": "array.range(end) | array.range(start, end, [step])",
            "source": "builtin:array",
            "line": 17
          },
          {
            "kind": "function",
            "name": "chunk",
            "signature": "array.chunk(array, size)",
            "source": "builtin:array",
            "line": 18
          },
          {
            "kind": "function",
            "name": "zip",
            "signature": "array.zip(array, ...)",
            "source": "builtin:array",
            "line": 19
          },
          {
            "kind": "function",
            "name": "repeat",
            "signature": "array.repeat(value, count)",
            "source": "builtin:array",
            "line": 20
          }
        ],
        "description": "배열 생성·복사·정렬·검색·집계",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "async",
        "symbol_count": 27,
        "symbols": [
          {
            "kind": "function",
            "name": "cmd",
            "signature": "async.cmd(command, [scope_id])",
            "source": "builtin:async",
            "line": 1
          },
          {
            "kind": "function",
            "name": "ready",
            "signature": "async.ready(task_id)",
            "source": "builtin:async",
            "line": 2
          },
          {
            "kind": "function",
            "name": "http_get",
            "signature": "async.http_get(url, [scope_id])",
            "source": "builtin:async",
            "line": 3
          },
          {
            "kind": "function",
            "name": "http_request",
            "signature": "async.http_request(spec, [scope_id])",
            "source": "builtin:async",
            "line": 4
          },
          {
            "kind": "function",
            "name": "sleep",
            "signature": "async.sleep(milliseconds, [scope_id])",
            "source": "builtin:async",
            "line": 5
          },
          {
            "kind": "function",
            "name": "sura",
            "signature": "async.sura(spec, [scope_id])",
            "source": "builtin:async",
            "line": 6
          },
          {
            "kind": "function",
            "name": "status",
            "signature": "async.status(task_id)",
            "source": "builtin:async",
            "line": 7
          },
          {
            "kind": "function",
            "name": "pending",
            "signature": "async.pending()",
            "source": "builtin:async",
            "line": 8
          },
          {
            "kind": "function",
            "name": "forget",
            "signature": "async.forget(task_id)",
            "source": "builtin:async",
            "line": 9
          },
          {
            "kind": "function",
            "name": "cleanup",
            "signature": "async.cleanup()",
            "source": "builtin:async",
            "line": 10
          },
          {
            "kind": "function",
            "name": "cancel",
            "signature": "async.cancel(task_id)",
            "source": "builtin:async",
            "line": 11
          },
          {
            "kind": "function",
            "name": "cancelled",
            "signature": "async.cancelled(task_id)",
            "source": "builtin:async",
            "line": 12
          },
          {
            "kind": "function",
            "name": "configure",
            "signature": "async.configure(max_workers, max_queue)",
            "source": "builtin:async",
            "line": 13
          },
          {
            "kind": "function",
            "name": "limits",
            "signature": "async.limits()",
            "source": "builtin:async",
            "line": 14
          },
          {
            "kind": "function",
            "name": "scope",
            "signature": "async.scope()",
            "source": "builtin:async",
            "line": 15
          },
          {
            "kind": "function",
            "name": "scope_open",
            "signature": "async.scope_open()",
            "source": "builtin:async",
            "line": 16
          },
          {
            "kind": "function",
            "name": "scope_attach",
            "signature": "async.scope_attach(scope_id, task_id)",
            "source": "builtin:async",
            "line": 17
          },
          {
            "kind": "function",
            "name": "scope_cancel",
            "signature": "async.scope_cancel(scope_id)",
            "source": "builtin:async",
            "line": 18
          },
          {
            "kind": "function",
            "name": "scope_status",
            "signature": "async.scope_status(scope_id)",
            "source": "builtin:async",
            "line": 19
          },
          {
            "kind": "function",
            "name": "scope_close",
            "signature": "async.scope_close(scope_id, [milliseconds])",
            "source": "builtin:async",
            "line": 20
          },
          {
            "kind": "function",
            "name": "scope_join",
            "signature": "async.scope_join(scope_id, [milliseconds])",
            "source": "builtin:async",
            "line": 21
          },
          {
            "kind": "function",
            "name": "await",
            "signature": "async.await(task_id)",
            "source": "builtin:async",
            "line": 22
          },
          {
            "kind": "function",
            "name": "await_timeout",
            "signature": "async.await_timeout(task_id, milliseconds, [default])",
            "source": "builtin:async",
            "line": 23
          },
          {
            "kind": "function",
            "name": "ready_all",
            "signature": "async.ready_all(task_ids)",
            "source": "builtin:async",
            "line": 24
          },
          {
            "kind": "function",
            "name": "any",
            "signature": "async.any(task_ids, [milliseconds], [default])",
            "source": "builtin:async",
            "line": 25
          },
          {
            "kind": "function",
            "name": "all",
            "signature": "async.all(task_ids)",
            "source": "builtin:async",
            "line": 26
          },
          {
            "kind": "function",
            "name": "all_timeout",
            "signature": "async.all_timeout(task_ids, milliseconds, [default])",
            "source": "builtin:async",
            "line": 27
          }
        ],
        "description": "bounded worker pool 기반 command·HTTP·timer task와 structured scope",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "autograd",
        "symbol_count": 63,
        "symbols": [
          {
            "kind": "function",
            "name": "tensor",
            "signature": "autograd.tensor(data, [options])",
            "source": "builtin:autograd",
            "line": 1
          },
          {
            "kind": "function",
            "name": "parameter",
            "signature": "autograd.parameter(data, [dtype_or_options])",
            "source": "builtin:autograd",
            "line": 2
          },
          {
            "kind": "function",
            "name": "zeros",
            "signature": "autograd.zeros(shape, [options])",
            "source": "builtin:autograd",
            "line": 3
          },
          {
            "kind": "function",
            "name": "ones",
            "signature": "autograd.ones(shape, [options])",
            "source": "builtin:autograd",
            "line": 4
          },
          {
            "kind": "function",
            "name": "randn",
            "signature": "autograd.randn(shape, [options])",
            "source": "builtin:autograd",
            "line": 5
          },
          {
            "kind": "function",
            "name": "data",
            "signature": "autograd.data(tensor)",
            "source": "builtin:autograd",
            "line": 6
          },
          {
            "kind": "function",
            "name": "grad",
            "signature": "autograd.grad(tensor)",
            "source": "builtin:autograd",
            "line": 7
          },
          {
            "kind": "function",
            "name": "dtype",
            "signature": "autograd.dtype(tensor)",
            "source": "builtin:autograd",
            "line": 8
          },
          {
            "kind": "function",
            "name": "device",
            "signature": "autograd.device(tensor)",
            "source": "builtin:autograd",
            "line": 9
          },
          {
            "kind": "function",
            "name": "to",
            "signature": "autograd.to(tensor, device)",
            "source": "builtin:autograd",
            "line": 10
          },
          {
            "kind": "function",
            "name": "storage_bytes",
            "signature": "autograd.storage_bytes(tensor)",
            "source": "builtin:autograd",
            "line": 11
          },
          {
            "kind": "function",
            "name": "cast",
            "signature": "autograd.cast(tensor, dtype)",
            "source": "builtin:autograd",
            "line": 12
          },
          {
            "kind": "function",
            "name": "shape",
            "signature": "autograd.shape(tensor)",
            "source": "builtin:autograd",
            "line": 13
          },
          {
            "kind": "function",
            "name": "numel",
            "signature": "autograd.numel(tensor)",
            "source": "builtin:autograd",
            "line": 14
          },
          {
            "kind": "function",
            "name": "limits",
            "signature": "autograd.limits()",
            "source": "builtin:autograd",
            "line": 15
          },
          {
            "kind": "function",
            "name": "item",
            "signature": "autograd.item(tensor)",
            "source": "builtin:autograd",
            "line": 16
          },
          {
            "kind": "function",
            "name": "detach",
            "signature": "autograd.detach(tensor)",
            "source": "builtin:autograd",
            "line": 17
          },
          {
            "kind": "function",
            "name": "requires_grad",
            "signature": "autograd.requires_grad(tensor)",
            "source": "builtin:autograd",
            "line": 18
          },
          {
            "kind": "function",
            "name": "set_requires_grad",
            "signature": "autograd.set_requires_grad(tensor, requires_grad)",
            "source": "builtin:autograd",
            "line": 19
          },
          {
            "kind": "function",
            "name": "add",
            "signature": "autograd.add(a, b)",
            "source": "builtin:autograd",
            "line": 20
          },
          {
            "kind": "function",
            "name": "sub",
            "signature": "autograd.sub(a, b)",
            "source": "builtin:autograd",
            "line": 21
          },
          {
            "kind": "function",
            "name": "mul",
            "signature": "autograd.mul(a, b)",
            "source": "builtin:autograd",
            "line": 22
          },
          {
            "kind": "function",
            "name": "div",
            "signature": "autograd.div(a, b)",
            "source": "builtin:autograd",
            "line": 23
          },
          {
            "kind": "function",
            "name": "neg",
            "signature": "autograd.neg(tensor)",
            "source": "builtin:autograd",
            "line": 24
          },
          {
            "kind": "function",
            "name": "reshape",
            "signature": "autograd.reshape(tensor, shape)",
            "source": "builtin:autograd",
            "line": 25
          },
          {
            "kind": "function",
            "name": "matmul",
            "signature": "autograd.matmul(a, b, [options])",
            "source": "builtin:autograd",
            "line": 26
          },
          {
            "kind": "function",
            "name": "transpose",
            "signature": "autograd.transpose(tensor, [axis1], [axis2])",
            "source": "builtin:autograd",
            "line": 27
          },
          {
            "kind": "function",
            "name": "linear",
            "signature": "autograd.linear(input, weights, [bias])",
            "source": "builtin:autograd",
            "line": 28
          },
          {
            "kind": "function",
            "name": "relu",
            "signature": "autograd.relu(tensor)",
            "source": "builtin:autograd",
            "line": 29
          },
          {
            "kind": "function",
            "name": "tanh",
            "signature": "autograd.tanh(tensor)",
            "source": "builtin:autograd",
            "line": 30
          },
          {
            "kind": "function",
            "name": "sigmoid",
            "signature": "autograd.sigmoid(tensor)",
            "source": "builtin:autograd",
            "line": 31
          },
          {
            "kind": "function",
            "name": "gelu",
            "signature": "autograd.gelu(tensor)",
            "source": "builtin:autograd",
            "line": 32
          },
          {
            "kind": "function",
            "name": "layer_norm",
            "signature": "autograd.layer_norm(tensor, [weight], [bias], [epsilon])",
            "source": "builtin:autograd",
            "line": 33
          },
          {
            "kind": "function",
            "name": "embedding",
            "signature": "autograd.embedding(token_ids, weight)",
            "source": "builtin:autograd",
            "line": 34
          },
          {
            "kind": "function",
            "name": "causal_attention",
            "signature": "autograd.causal_attention(query, key, value, [options])",
            "source": "builtin:autograd",
            "line": 35
          },
          {
            "kind": "function",
            "name": "softmax",
            "signature": "autograd.softmax(tensor)",
            "source": "builtin:autograd",
            "line": 36
          },
          {
            "kind": "function",
            "name": "sum",
            "signature": "autograd.sum(tensor)",
            "source": "builtin:autograd",
            "line": 37
          },
          {
            "kind": "function",
            "name": "mean",
            "signature": "autograd.mean(tensor)",
            "source": "builtin:autograd",
            "line": 38
          },
          {
            "kind": "function",
            "name": "mse",
            "signature": "autograd.mse(prediction, target)",
            "source": "builtin:autograd",
            "line": 39
          },
          {
            "kind": "function",
            "name": "bce",
            "signature": "autograd.bce(probabilities, target)",
            "source": "builtin:autograd",
            "line": 40
          },
          {
            "kind": "function",
            "name": "bce_logits",
            "signature": "autograd.bce_logits(logits, target)",
            "source": "builtin:autograd",
            "line": 41
          },
          {
            "kind": "function",
            "name": "cross_entropy",
            "signature": "autograd.cross_entropy(logits, one_hot_targets)",
            "source": "builtin:autograd",
            "line": 42
          },
          {
            "kind": "function",
            "name": "cross_entropy_ids",
            "signature": "autograd.cross_entropy_ids(logits, class_ids)",
            "source": "builtin:autograd",
            "line": 43
          },
          {
            "kind": "function",
            "name": "backward",
            "signature": "autograd.backward(tensor, [gradient], [retain_graph])",
            "source": "builtin:autograd",
            "line": 44
          },
          {
            "kind": "function",
            "name": "zero_grad",
            "signature": "autograd.zero_grad(parameters)",
            "source": "builtin:autograd",
            "line": 45
          },
          {
            "kind": "function",
            "name": "sgd",
            "signature": "autograd.sgd(parameters, learning_rate, [options])",
            "source": "builtin:autograd",
            "line": 46
          },
          {
            "kind": "function",
            "name": "adam",
            "signature": "autograd.adam(parameters, learning_rate, [options])",
            "source": "builtin:autograd",
            "line": 47
          },
          {
            "kind": "function",
            "name": "reset_optimizer",
            "signature": "autograd.reset_optimizer(parameters)",
            "source": "builtin:autograd",
            "line": 48
          },
          {
            "kind": "function",
            "name": "grad_norm",
            "signature": "autograd.grad_norm(parameters)",
            "source": "builtin:autograd",
            "line": 49
          },
          {
            "kind": "function",
            "name": "clip_grad_norm",
            "signature": "autograd.clip_grad_norm(parameters, max_norm)",
            "source": "builtin:autograd",
            "line": 50
          },
          {
            "kind": "function",
            "name": "save_checkpoint",
            "signature": "autograd.save_checkpoint(state_dict, path, [options])",
            "source": "builtin:autograd",
            "line": 51
          },
          {
            "kind": "function",
            "name": "load_checkpoint",
            "signature": "autograd.load_checkpoint(path, [options])",
            "source": "builtin:autograd",
            "line": 52
          },
          {
            "kind": "function",
            "name": "cuda_available",
            "signature": "autograd.cuda_available()",
            "source": "builtin:autograd",
            "line": 53
          },
          {
            "kind": "function",
            "name": "cuda_info",
            "signature": "autograd.cuda_info()",
            "source": "builtin:autograd",
            "line": 54
          },
          {
            "kind": "function",
            "name": "cuda_stats",
            "signature": "autograd.cuda_stats()",
            "source": "builtin:autograd",
            "line": 55
          },
          {
            "kind": "function",
            "name": "cuda_reset_stats",
            "signature": "autograd.cuda_reset_stats()",
            "source": "builtin:autograd",
            "line": 56
          },
          {
            "kind": "function",
            "name": "cuda_synchronize",
            "signature": "autograd.cuda_synchronize()",
            "source": "builtin:autograd",
            "line": 57
          },
          {
            "kind": "function",
            "name": "save_safetensors",
            "signature": "autograd.save_safetensors(state_dict, path)",
            "source": "builtin:autograd",
            "line": 58
          },
          {
            "kind": "function",
            "name": "load_safetensors",
            "signature": "autograd.load_safetensors(path, [options])",
            "source": "builtin:autograd",
            "line": 59
          },
          {
            "kind": "function",
            "name": "save_onnx_weights",
            "signature": "autograd.save_onnx_weights(state_dict, path)",
            "source": "builtin:autograd",
            "line": 60
          },
          {
            "kind": "function",
            "name": "load_onnx_weights",
            "signature": "autograd.load_onnx_weights(path, [options])",
            "source": "builtin:autograd",
            "line": 61
          },
          {
            "kind": "function",
            "name": "run_onnx",
            "signature": "autograd.run_onnx(path, inputs, [options])",
            "source": "builtin:autograd",
            "line": 62
          },
          {
            "kind": "function",
            "name": "all_reduce_gradients",
            "signature": "autograd.all_reduce_gradients(parameters, options)",
            "source": "builtin:autograd",
            "line": 63
          }
        ],
        "description": "typed Tensor, reverse-mode 자동미분, CPU/CUDA 연산, optimizer와 bounded CPU ONNX 실행",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "cli",
        "symbol_count": 4,
        "symbols": [
          {
            "kind": "function",
            "name": "parse",
            "signature": "cli.parse(text, [value_flags])",
            "source": "builtin:cli",
            "line": 1
          },
          {
            "kind": "function",
            "name": "argv",
            "signature": "cli.argv()",
            "source": "builtin:cli",
            "line": 2
          },
          {
            "kind": "function",
            "name": "argc",
            "signature": "cli.argc()",
            "source": "builtin:cli",
            "line": 3
          },
          {
            "kind": "function",
            "name": "script_name",
            "signature": "cli.script_name()",
            "source": "builtin:cli",
            "line": 4
          }
        ],
        "description": "스크립트 인자와 명령행 문자열 파싱",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "crypto",
        "symbol_count": 38,
        "symbols": [
          {
            "kind": "function",
            "name": "sha256",
            "signature": "crypto.sha256(text)",
            "source": "builtin:crypto",
            "line": 1
          },
          {
            "kind": "function",
            "name": "file_sha256",
            "signature": "crypto.file_sha256(path)",
            "source": "builtin:crypto",
            "line": 2
          },
          {
            "kind": "function",
            "name": "hmac_sha256",
            "signature": "crypto.hmac_sha256(key, message)",
            "source": "builtin:crypto",
            "line": 3
          },
          {
            "kind": "function",
            "name": "file_hmac_sha256",
            "signature": "crypto.file_hmac_sha256(key, path)",
            "source": "builtin:crypto",
            "line": 4
          },
          {
            "kind": "function",
            "name": "random_bytes",
            "signature": "crypto.random_bytes(count)",
            "source": "builtin:crypto",
            "line": 5
          },
          {
            "kind": "function",
            "name": "random_hex",
            "signature": "crypto.random_hex(count)",
            "source": "builtin:crypto",
            "line": 6
          },
          {
            "kind": "function",
            "name": "constant_time_eq",
            "signature": "crypto.constant_time_eq(left, right)",
            "source": "builtin:crypto",
            "line": 7
          },
          {
            "kind": "function",
            "name": "hex_encode",
            "signature": "crypto.hex_encode(text)",
            "source": "builtin:crypto",
            "line": 8
          },
          {
            "kind": "function",
            "name": "hex_decode",
            "signature": "crypto.hex_decode(text)",
            "source": "builtin:crypto",
            "line": 9
          },
          {
            "kind": "function",
            "name": "base64_encode",
            "signature": "crypto.base64_encode(text)",
            "source": "builtin:crypto",
            "line": 10
          },
          {
            "kind": "function",
            "name": "base64_decode",
            "signature": "crypto.base64_decode(text)",
            "source": "builtin:crypto",
            "line": 11
          },
          {
            "kind": "function",
            "name": "base64_url_encode",
            "signature": "crypto.base64_url_encode(text)",
            "source": "builtin:crypto",
            "line": 12
          },
          {
            "kind": "function",
            "name": "base64_url_decode",
            "signature": "crypto.base64_url_decode(text)",
            "source": "builtin:crypto",
            "line": 13
          },
          {
            "kind": "function",
            "name": "url_encode",
            "signature": "crypto.url_encode(text)",
            "source": "builtin:crypto",
            "line": 14
          },
          {
            "kind": "function",
            "name": "url_decode",
            "signature": "crypto.url_decode(text)",
            "source": "builtin:crypto",
            "line": 15
          },
          {
            "kind": "function",
            "name": "url_parse",
            "signature": "crypto.url_parse(url)",
            "source": "builtin:crypto",
            "line": 16
          },
          {
            "kind": "function",
            "name": "url_build",
            "signature": "crypto.url_build(parts)",
            "source": "builtin:crypto",
            "line": 17
          },
          {
            "kind": "function",
            "name": "query_build",
            "signature": "crypto.query_build(params)",
            "source": "builtin:crypto",
            "line": 18
          },
          {
            "kind": "function",
            "name": "query_parse",
            "signature": "crypto.query_parse(query)",
            "source": "builtin:crypto",
            "line": 19
          },
          {
            "kind": "function",
            "name": "form_build",
            "signature": "crypto.form_build(params)",
            "source": "builtin:crypto",
            "line": 20
          },
          {
            "kind": "function",
            "name": "form_parse",
            "signature": "crypto.form_parse(body)",
            "source": "builtin:crypto",
            "line": 21
          },
          {
            "kind": "function",
            "name": "auth_bearer",
            "signature": "crypto.auth_bearer(token)",
            "source": "builtin:crypto",
            "line": 22
          },
          {
            "kind": "function",
            "name": "auth_basic",
            "signature": "crypto.auth_basic(username, password)",
            "source": "builtin:crypto",
            "line": 23
          },
          {
            "kind": "function",
            "name": "headers_merge",
            "signature": "crypto.headers_merge(headers, ...)",
            "source": "builtin:crypto",
            "line": 24
          },
          {
            "kind": "function",
            "name": "headers_get",
            "signature": "crypto.headers_get(headers, name, [default])",
            "source": "builtin:crypto",
            "line": 25
          },
          {
            "kind": "function",
            "name": "headers_has",
            "signature": "crypto.headers_has(headers, name)",
            "source": "builtin:crypto",
            "line": 26
          },
          {
            "kind": "function",
            "name": "headers_redact",
            "signature": "crypto.headers_redact(headers, [names], [mask])",
            "source": "builtin:crypto",
            "line": 27
          },
          {
            "kind": "function",
            "name": "cookie_parse",
            "signature": "crypto.cookie_parse(header_or_headers)",
            "source": "builtin:crypto",
            "line": 28
          },
          {
            "kind": "function",
            "name": "cookie_build",
            "signature": "crypto.cookie_build(cookies)",
            "source": "builtin:crypto",
            "line": 29
          },
          {
            "kind": "function",
            "name": "cookie_get",
            "signature": "crypto.cookie_get(header_or_cookies, name, [default])",
            "source": "builtin:crypto",
            "line": 30
          },
          {
            "kind": "function",
            "name": "content_type",
            "signature": "crypto.content_type(headers_or_value, [default])",
            "source": "builtin:crypto",
            "line": 31
          },
          {
            "kind": "function",
            "name": "charset",
            "signature": "crypto.charset(headers_or_value, [default])",
            "source": "builtin:crypto",
            "line": 32
          },
          {
            "kind": "function",
            "name": "is_json",
            "signature": "crypto.is_json(headers_or_value)",
            "source": "builtin:crypto",
            "line": 33
          },
          {
            "kind": "function",
            "name": "status_ok",
            "signature": "crypto.status_ok(status)",
            "source": "builtin:crypto",
            "line": 34
          },
          {
            "kind": "function",
            "name": "status_text",
            "signature": "crypto.status_text(status)",
            "source": "builtin:crypto",
            "line": 35
          },
          {
            "kind": "function",
            "name": "status_retryable",
            "signature": "crypto.status_retryable(status)",
            "source": "builtin:crypto",
            "line": 36
          },
          {
            "kind": "function",
            "name": "retry_after",
            "signature": "crypto.retry_after(headers_or_value, [default_ms])",
            "source": "builtin:crypto",
            "line": 37
          },
          {
            "kind": "function",
            "name": "backoff_delays",
            "signature": "crypto.backoff_delays(attempts, [base_ms], [factor], [max_ms])",
            "source": "builtin:crypto",
            "line": 38
          }
        ],
        "description": "SHA-256, HMAC, 인코딩, URL·header·cookie 도우미",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "dataset",
        "symbol_count": 6,
        "symbols": [
          {
            "kind": "function",
            "name": "pack_text",
            "signature": "dataset.pack_text(source, tokenizer, path, [options])",
            "source": "builtin:dataset",
            "line": 1
          },
          {
            "kind": "function",
            "name": "open",
            "signature": "dataset.open(path, [options])",
            "source": "builtin:dataset",
            "line": 2
          },
          {
            "kind": "function",
            "name": "next",
            "signature": "dataset.next(loader)",
            "source": "builtin:dataset",
            "line": 3
          },
          {
            "kind": "function",
            "name": "reset",
            "signature": "dataset.reset(loader, [epoch])",
            "source": "builtin:dataset",
            "line": 4
          },
          {
            "kind": "function",
            "name": "close",
            "signature": "dataset.close(loader)",
            "source": "builtin:dataset",
            "line": 5
          },
          {
            "kind": "function",
            "name": "info",
            "signature": "dataset.info(loader)",
            "source": "builtin:dataset",
            "line": 6
          }
        ],
        "description": "uint32 text shard 생성과 seek 기반 batch reader",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "datetime",
        "symbol_count": 8,
        "symbols": [
          {
            "kind": "function",
            "name": "now",
            "signature": "datetime.now()",
            "source": "builtin:datetime",
            "line": 1
          },
          {
            "kind": "function",
            "name": "parse",
            "signature": "datetime.parse(text, [format])",
            "source": "builtin:datetime",
            "line": 2
          },
          {
            "kind": "function",
            "name": "format",
            "signature": "datetime.format(timestamp, format)",
            "source": "builtin:datetime",
            "line": 3
          },
          {
            "kind": "function",
            "name": "utc_format",
            "signature": "datetime.utc_format(timestamp, format)",
            "source": "builtin:datetime",
            "line": 4
          },
          {
            "kind": "function",
            "name": "parts",
            "signature": "datetime.parts(timestamp, [utc])",
            "source": "builtin:datetime",
            "line": 5
          },
          {
            "kind": "function",
            "name": "add",
            "signature": "datetime.add(timestamp, seconds)",
            "source": "builtin:datetime",
            "line": 6
          },
          {
            "kind": "function",
            "name": "diff",
            "signature": "datetime.diff(end_timestamp, start_timestamp)",
            "source": "builtin:datetime",
            "line": 7
          },
          {
            "kind": "function",
            "name": "timestamp",
            "signature": "datetime.timestamp()",
            "source": "builtin:datetime",
            "line": 8
          }
        ],
        "description": "현재 시각, 형식화, 파싱, 날짜 계산",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "db",
        "symbol_count": 12,
        "symbols": [
          {
            "kind": "function",
            "name": "set",
            "signature": "db.set(path, key, value)",
            "source": "builtin:db",
            "line": 1
          },
          {
            "kind": "function",
            "name": "get",
            "signature": "db.get(path, key, [default])",
            "source": "builtin:db",
            "line": 2
          },
          {
            "kind": "function",
            "name": "has",
            "signature": "db.has(path, key)",
            "source": "builtin:db",
            "line": 3
          },
          {
            "kind": "function",
            "name": "delete",
            "signature": "db.delete(path, key)",
            "source": "builtin:db",
            "line": 4
          },
          {
            "kind": "function",
            "name": "keys",
            "signature": "db.keys(path)",
            "source": "builtin:db",
            "line": 5
          },
          {
            "kind": "function",
            "name": "all",
            "signature": "db.all(path)",
            "source": "builtin:db",
            "line": 6
          },
          {
            "kind": "function",
            "name": "insert",
            "signature": "db.insert(path, row)",
            "source": "builtin:db",
            "line": 7
          },
          {
            "kind": "function",
            "name": "find",
            "signature": "db.find(path, criteria)",
            "source": "builtin:db",
            "line": 8
          },
          {
            "kind": "function",
            "name": "count",
            "signature": "db.count(path, [criteria])",
            "source": "builtin:db",
            "line": 9
          },
          {
            "kind": "function",
            "name": "update",
            "signature": "db.update(path, criteria, patch)",
            "source": "builtin:db",
            "line": 10
          },
          {
            "kind": "function",
            "name": "remove",
            "signature": "db.remove(path, criteria)",
            "source": "builtin:db",
            "line": 11
          },
          {
            "kind": "function",
            "name": "query",
            "signature": "db.query(path, [criteria], [options])",
            "source": "builtin:db",
            "line": 12
          }
        ],
        "description": "파일 기반 key/value와 record 작업",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "fs",
        "symbol_count": 21,
        "symbols": [
          {
            "kind": "function",
            "name": "read",
            "signature": "fs.read(path)",
            "source": "builtin:fs",
            "line": 1
          },
          {
            "kind": "function",
            "name": "write",
            "signature": "fs.write(path, text)",
            "source": "builtin:fs",
            "line": 2
          },
          {
            "kind": "function",
            "name": "read_json",
            "signature": "fs.read_json(path)",
            "source": "builtin:fs",
            "line": 3
          },
          {
            "kind": "function",
            "name": "write_json",
            "signature": "fs.write_json(path, value)",
            "source": "builtin:fs",
            "line": 4
          },
          {
            "kind": "function",
            "name": "read_bytes",
            "signature": "fs.read_bytes(path)",
            "source": "builtin:fs",
            "line": 5
          },
          {
            "kind": "function",
            "name": "write_bytes",
            "signature": "fs.write_bytes(path, bytes)",
            "source": "builtin:fs",
            "line": 6
          },
          {
            "kind": "function",
            "name": "sha256",
            "signature": "fs.sha256(path)",
            "source": "builtin:fs",
            "line": 7
          },
          {
            "kind": "function",
            "name": "append",
            "signature": "fs.append(path, text)",
            "source": "builtin:fs",
            "line": 8
          },
          {
            "kind": "function",
            "name": "exists",
            "signature": "fs.exists(path)",
            "source": "builtin:fs",
            "line": 9
          },
          {
            "kind": "function",
            "name": "delete",
            "signature": "fs.delete(path)",
            "source": "builtin:fs",
            "line": 10
          },
          {
            "kind": "function",
            "name": "remove_tree",
            "signature": "fs.remove_tree(path)",
            "source": "builtin:fs",
            "line": 11
          },
          {
            "kind": "function",
            "name": "list",
            "signature": "fs.list(path)",
            "source": "builtin:fs",
            "line": 12
          },
          {
            "kind": "function",
            "name": "walk",
            "signature": "fs.walk(path, [extension])",
            "source": "builtin:fs",
            "line": 13
          },
          {
            "kind": "function",
            "name": "glob",
            "signature": "fs.glob(pattern)",
            "source": "builtin:fs",
            "line": 14
          },
          {
            "kind": "function",
            "name": "mkdir",
            "signature": "fs.mkdir(path)",
            "source": "builtin:fs",
            "line": 15
          },
          {
            "kind": "function",
            "name": "cwd",
            "signature": "fs.cwd()",
            "source": "builtin:fs",
            "line": 16
          },
          {
            "kind": "function",
            "name": "join",
            "signature": "fs.join(part, ...)",
            "source": "builtin:fs",
            "line": 17
          },
          {
            "kind": "function",
            "name": "basename",
            "signature": "fs.basename(path)",
            "source": "builtin:fs",
            "line": 18
          },
          {
            "kind": "function",
            "name": "dirname",
            "signature": "fs.dirname(path)",
            "source": "builtin:fs",
            "line": 19
          },
          {
            "kind": "function",
            "name": "copy",
            "signature": "fs.copy(src, dst, [overwrite])",
            "source": "builtin:fs",
            "line": 20
          },
          {
            "kind": "function",
            "name": "move",
            "signature": "fs.move(src, dst, [overwrite])",
            "source": "builtin:fs",
            "line": 21
          }
        ],
        "description": "파일·디렉터리 읽기, 쓰기, 탐색, 이동",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "dict",
        "symbol_count": 7,
        "symbols": [
          {
            "kind": "function",
            "name": "keys",
            "signature": "dict.keys(dict)",
            "source": "builtin:dict",
            "line": 1
          },
          {
            "kind": "function",
            "name": "values",
            "signature": "dict.values(dict)",
            "source": "builtin:dict",
            "line": 2
          },
          {
            "kind": "function",
            "name": "items",
            "signature": "dict.items(dict)",
            "source": "builtin:dict",
            "line": 3
          },
          {
            "kind": "function",
            "name": "merge",
            "signature": "dict.merge(dict, ...)",
            "source": "builtin:dict",
            "line": 4
          },
          {
            "kind": "function",
            "name": "pick",
            "signature": "dict.pick(dict, keys)",
            "source": "builtin:dict",
            "line": 5
          },
          {
            "kind": "function",
            "name": "omit",
            "signature": "dict.omit(dict, keys)",
            "source": "builtin:dict",
            "line": 6
          },
          {
            "kind": "function",
            "name": "get_path",
            "signature": "dict.get_path(value, path, [default])",
            "source": "builtin:dict",
            "line": 7
          }
        ],
        "description": "dictionary keys·values·merge·pick·path",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "ffi",
        "symbol_count": 2,
        "symbols": [
          {
            "kind": "function",
            "name": "load",
            "signature": "ffi.load(path)",
            "source": "builtin:ffi",
            "line": 1
          },
          {
            "kind": "function",
            "name": "call",
            "signature": "ffi.call(lib, symbol, signature, ...args)",
            "source": "builtin:ffi",
            "line": 2
          }
        ],
        "description": "동적 C ABI library load와 symbol call",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "graphics3d",
        "symbol_count": 10,
        "symbols": [
          {
            "kind": "function",
            "name": "identity",
            "signature": "graphics3d.identity()",
            "source": "builtin:graphics3d",
            "line": 1
          },
          {
            "kind": "function",
            "name": "translate",
            "signature": "graphics3d.translate(x, y, z)",
            "source": "builtin:graphics3d",
            "line": 2
          },
          {
            "kind": "function",
            "name": "scale",
            "signature": "graphics3d.scale(x, y, z)",
            "source": "builtin:graphics3d",
            "line": 3
          },
          {
            "kind": "function",
            "name": "rotate_y",
            "signature": "graphics3d.rotate_y(radians)",
            "source": "builtin:graphics3d",
            "line": 4
          },
          {
            "kind": "function",
            "name": "mul",
            "signature": "graphics3d.mul(left, right)",
            "source": "builtin:graphics3d",
            "line": 5
          },
          {
            "kind": "function",
            "name": "cube",
            "signature": "graphics3d.cube([size], [center])",
            "source": "builtin:graphics3d",
            "line": 6
          },
          {
            "kind": "function",
            "name": "transform",
            "signature": "graphics3d.transform(mesh, matrix4)",
            "source": "builtin:graphics3d",
            "line": 7
          },
          {
            "kind": "function",
            "name": "bounds",
            "signature": "graphics3d.bounds(mesh)",
            "source": "builtin:graphics3d",
            "line": 8
          },
          {
            "kind": "function",
            "name": "face_normals",
            "signature": "graphics3d.face_normals(mesh)",
            "source": "builtin:graphics3d",
            "line": 9
          },
          {
            "kind": "function",
            "name": "project",
            "signature": "graphics3d.project(point, camera, [width], [height])",
            "source": "builtin:graphics3d",
            "line": 10
          }
        ],
        "description": "4x4 matrix, cube mesh, transform, bounds, camera projection",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "http",
        "symbol_count": 37,
        "symbols": [
          {
            "kind": "function",
            "name": "get",
            "signature": "http.get(url)",
            "source": "builtin:http",
            "line": 1
          },
          {
            "kind": "function",
            "name": "json",
            "signature": "http.json(url)",
            "source": "builtin:http",
            "line": 2
          },
          {
            "kind": "function",
            "name": "post",
            "signature": "http.post(url, body, [content_type])",
            "source": "builtin:http",
            "line": 3
          },
          {
            "kind": "function",
            "name": "request",
            "signature": "http.request(spec)",
            "source": "builtin:http",
            "line": 4
          },
          {
            "kind": "function",
            "name": "request_full",
            "signature": "http.request_full(spec)",
            "source": "builtin:http",
            "line": 5
          },
          {
            "kind": "function",
            "name": "request_retry",
            "signature": "http.request_retry(spec, [attempts], [delay_ms])",
            "source": "builtin:http",
            "line": 6
          },
          {
            "kind": "function",
            "name": "request_json",
            "signature": "http.request_json(spec)",
            "source": "builtin:http",
            "line": 7
          },
          {
            "kind": "function",
            "name": "request_json_checked",
            "signature": "http.request_json_checked(spec)",
            "source": "builtin:http",
            "line": 8
          },
          {
            "kind": "function",
            "name": "request_retry_json",
            "signature": "http.request_retry_json(spec, [attempts], [delay_ms])",
            "source": "builtin:http",
            "line": 9
          },
          {
            "kind": "function",
            "name": "request_retry_json_checked",
            "signature": "http.request_retry_json_checked(spec, [attempts], [delay_ms])",
            "source": "builtin:http",
            "line": 10
          },
          {
            "kind": "function",
            "name": "serve_static",
            "signature": "http.serve_static(path, [port])",
            "source": "builtin:http",
            "line": 11
          },
          {
            "kind": "function",
            "name": "serve_routes",
            "signature": "http.serve_routes(routes, [port])",
            "source": "builtin:http",
            "line": 12
          },
          {
            "kind": "function",
            "name": "server_url",
            "signature": "http.server_url(server)",
            "source": "builtin:http",
            "line": 13
          },
          {
            "kind": "function",
            "name": "server_stop",
            "signature": "http.server_stop(server)",
            "source": "builtin:http",
            "line": 14
          },
          {
            "kind": "function",
            "name": "url_parse",
            "signature": "http.url_parse(url)",
            "source": "builtin:http",
            "line": 15
          },
          {
            "kind": "function",
            "name": "url_build",
            "signature": "http.url_build(parts)",
            "source": "builtin:http",
            "line": 16
          },
          {
            "kind": "function",
            "name": "query_build",
            "signature": "http.query_build(params)",
            "source": "builtin:http",
            "line": 17
          },
          {
            "kind": "function",
            "name": "query_parse",
            "signature": "http.query_parse(query)",
            "source": "builtin:http",
            "line": 18
          },
          {
            "kind": "function",
            "name": "form_build",
            "signature": "http.form_build(params)",
            "source": "builtin:http",
            "line": 19
          },
          {
            "kind": "function",
            "name": "form_parse",
            "signature": "http.form_parse(body)",
            "source": "builtin:http",
            "line": 20
          },
          {
            "kind": "function",
            "name": "auth_bearer",
            "signature": "http.auth_bearer(token)",
            "source": "builtin:http",
            "line": 21
          },
          {
            "kind": "function",
            "name": "auth_basic",
            "signature": "http.auth_basic(username, password)",
            "source": "builtin:http",
            "line": 22
          },
          {
            "kind": "function",
            "name": "headers_merge",
            "signature": "http.headers_merge(headers, ...)",
            "source": "builtin:http",
            "line": 23
          },
          {
            "kind": "function",
            "name": "headers_get",
            "signature": "http.headers_get(headers, name, [default])",
            "source": "builtin:http",
            "line": 24
          },
          {
            "kind": "function",
            "name": "headers_has",
            "signature": "http.headers_has(headers, name)",
            "source": "builtin:http",
            "line": 25
          },
          {
            "kind": "function",
            "name": "headers_redact",
            "signature": "http.headers_redact(headers, [names], [mask])",
            "source": "builtin:http",
            "line": 26
          },
          {
            "kind": "function",
            "name": "cookie_parse",
            "signature": "http.cookie_parse(header_or_headers)",
            "source": "builtin:http",
            "line": 27
          },
          {
            "kind": "function",
            "name": "cookie_build",
            "signature": "http.cookie_build(cookies)",
            "source": "builtin:http",
            "line": 28
          },
          {
            "kind": "function",
            "name": "cookie_get",
            "signature": "http.cookie_get(header_or_cookies, name, [default])",
            "source": "builtin:http",
            "line": 29
          },
          {
            "kind": "function",
            "name": "content_type",
            "signature": "http.content_type(headers_or_value, [default])",
            "source": "builtin:http",
            "line": 30
          },
          {
            "kind": "function",
            "name": "charset",
            "signature": "http.charset(headers_or_value, [default])",
            "source": "builtin:http",
            "line": 31
          },
          {
            "kind": "function",
            "name": "is_json",
            "signature": "http.is_json(headers_or_value)",
            "source": "builtin:http",
            "line": 32
          },
          {
            "kind": "function",
            "name": "status_ok",
            "signature": "http.status_ok(status)",
            "source": "builtin:http",
            "line": 33
          },
          {
            "kind": "function",
            "name": "status_text",
            "signature": "http.status_text(status)",
            "source": "builtin:http",
            "line": 34
          },
          {
            "kind": "function",
            "name": "status_retryable",
            "signature": "http.status_retryable(status)",
            "source": "builtin:http",
            "line": 35
          },
          {
            "kind": "function",
            "name": "retry_after",
            "signature": "http.retry_after(headers_or_value, [default_ms])",
            "source": "builtin:http",
            "line": 36
          },
          {
            "kind": "function",
            "name": "backoff_delays",
            "signature": "http.backoff_delays(attempts, [base_ms], [factor], [max_ms])",
            "source": "builtin:http",
            "line": 37
          }
        ],
        "description": "HTTP client, retry, local server, URL·form·header helpers",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "json",
        "symbol_count": 28,
        "symbols": [
          {
            "kind": "function",
            "name": "parse",
            "signature": "json.parse(text)",
            "source": "builtin:json",
            "line": 1
          },
          {
            "kind": "function",
            "name": "try_parse",
            "signature": "json.try_parse(text, [fallback])",
            "source": "builtin:json",
            "line": 2
          },
          {
            "kind": "function",
            "name": "stringify",
            "signature": "json.stringify(value)",
            "source": "builtin:json",
            "line": 3
          },
          {
            "kind": "function",
            "name": "pretty",
            "signature": "json.pretty(value, [indent])",
            "source": "builtin:json",
            "line": 4
          },
          {
            "kind": "function",
            "name": "path",
            "signature": "json.path(value, path, [default])",
            "source": "builtin:json",
            "line": 5
          },
          {
            "kind": "function",
            "name": "get_path",
            "signature": "json.get_path(value, path, [default])",
            "source": "builtin:json",
            "line": 6
          },
          {
            "kind": "function",
            "name": "has_path",
            "signature": "json.has_path(value, path)",
            "source": "builtin:json",
            "line": 7
          },
          {
            "kind": "function",
            "name": "merge_patch",
            "signature": "json.merge_patch(target, patch)",
            "source": "builtin:json",
            "line": 8
          },
          {
            "kind": "function",
            "name": "delete_path",
            "signature": "json.delete_path(value, path)",
            "source": "builtin:json",
            "line": 9
          },
          {
            "kind": "function",
            "name": "set_path",
            "signature": "json.set_path(value, path, new_value)",
            "source": "builtin:json",
            "line": 10
          },
          {
            "kind": "function",
            "name": "schema_validate",
            "signature": "json.schema_validate(value, schema)",
            "source": "builtin:json",
            "line": 11
          },
          {
            "kind": "function",
            "name": "schema_errors",
            "signature": "json.schema_errors(value, schema)",
            "source": "builtin:json",
            "line": 12
          },
          {
            "kind": "function",
            "name": "schema_to_json_schema",
            "signature": "json.schema_to_json_schema(schema, [strict])",
            "source": "builtin:json",
            "line": 13
          },
          {
            "kind": "function",
            "name": "to_json_schema",
            "signature": "json.to_json_schema(schema, [strict])",
            "source": "builtin:json",
            "line": 14
          },
          {
            "kind": "function",
            "name": "template_render",
            "signature": "json.template_render(text, data, [missing])",
            "source": "builtin:json",
            "line": 15
          },
          {
            "kind": "function",
            "name": "render",
            "signature": "json.render(text, data, [missing])",
            "source": "builtin:json",
            "line": 16
          },
          {
            "kind": "function",
            "name": "pluck",
            "signature": "json.pluck(rows, path, [default])",
            "source": "builtin:json",
            "line": 17
          },
          {
            "kind": "function",
            "name": "count_by",
            "signature": "json.count_by(rows, path)",
            "source": "builtin:json",
            "line": 18
          },
          {
            "kind": "function",
            "name": "group_by",
            "signature": "json.group_by(rows, path)",
            "source": "builtin:json",
            "line": 19
          },
          {
            "kind": "function",
            "name": "sort_by",
            "signature": "json.sort_by(rows, path, [descending])",
            "source": "builtin:json",
            "line": 20
          },
          {
            "kind": "function",
            "name": "jsonl_parse",
            "signature": "json.jsonl_parse(text)",
            "source": "builtin:json",
            "line": 21
          },
          {
            "kind": "function",
            "name": "jsonl_stringify",
            "signature": "json.jsonl_stringify(rows, [trailing_newline])",
            "source": "builtin:json",
            "line": 22
          },
          {
            "kind": "function",
            "name": "sse_parse",
            "signature": "json.sse_parse(text)",
            "source": "builtin:json",
            "line": 23
          },
          {
            "kind": "function",
            "name": "sse_data",
            "signature": "json.sse_data(text, [parse_json])",
            "source": "builtin:json",
            "line": 24
          },
          {
            "kind": "function",
            "name": "csv_parse",
            "signature": "json.csv_parse(text, [has_header])",
            "source": "builtin:json",
            "line": 25
          },
          {
            "kind": "function",
            "name": "csv_stringify",
            "signature": "json.csv_stringify(rows, [headers])",
            "source": "builtin:json",
            "line": 26
          },
          {
            "kind": "function",
            "name": "ini_parse",
            "signature": "json.ini_parse(text)",
            "source": "builtin:json",
            "line": 27
          },
          {
            "kind": "function",
            "name": "ini_stringify",
            "signature": "json.ini_stringify(dict)",
            "source": "builtin:json",
            "line": 28
          }
        ],
        "description": "JSON·JSONL·SSE·CSV·INI 변환, path와 schema 검사",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "llm",
        "symbol_count": 30,
        "symbols": [
          {
            "kind": "function",
            "name": "message",
            "signature": "llm.message(role, content)",
            "source": "builtin:llm",
            "line": 1
          },
          {
            "kind": "function",
            "name": "messages",
            "signature": "llm.messages([system], user)",
            "source": "builtin:llm",
            "line": 2
          },
          {
            "kind": "function",
            "name": "rag_messages",
            "signature": "llm.rag_messages(question, context, [system])",
            "source": "builtin:llm",
            "line": 3
          },
          {
            "kind": "function",
            "name": "request",
            "signature": "llm.request(model, messages, [temperature])",
            "source": "builtin:llm",
            "line": 4
          },
          {
            "kind": "function",
            "name": "request_json",
            "signature": "llm.request_json(model, messages, [temperature])",
            "source": "builtin:llm",
            "line": 5
          },
          {
            "kind": "function",
            "name": "response_schema",
            "signature": "llm.response_schema(name, schema, [strict])",
            "source": "builtin:llm",
            "line": 6
          },
          {
            "kind": "function",
            "name": "request_schema",
            "signature": "llm.request_schema(model, messages, schema, [temperature], [name], [strict])",
            "source": "builtin:llm",
            "line": 7
          },
          {
            "kind": "function",
            "name": "request_schema_json",
            "signature": "llm.request_schema_json(model, messages, schema, [temperature], [name], [strict])",
            "source": "builtin:llm",
            "line": 8
          },
          {
            "kind": "function",
            "name": "tools",
            "signature": "llm.tools([names])",
            "source": "builtin:llm",
            "line": 9
          },
          {
            "kind": "function",
            "name": "tool_schemas",
            "signature": "llm.tool_schemas([names])",
            "source": "builtin:llm",
            "line": 10
          },
          {
            "kind": "function",
            "name": "request_tools",
            "signature": "llm.request_tools(model, messages, tool_names, [temperature])",
            "source": "builtin:llm",
            "line": 11
          },
          {
            "kind": "function",
            "name": "request_tools_json",
            "signature": "llm.request_tools_json(model, messages, tool_names, [temperature])",
            "source": "builtin:llm",
            "line": 12
          },
          {
            "kind": "function",
            "name": "request_tools_schema",
            "signature": "llm.request_tools_schema(model, messages, tool_names, schema, [temperature], [name], [strict])",
            "source": "builtin:llm",
            "line": 13
          },
          {
            "kind": "function",
            "name": "request_tools_schema_json",
            "signature": "llm.request_tools_schema_json(model, messages, tool_names, schema, [temperature], [name], [strict])",
            "source": "builtin:llm",
            "line": 14
          },
          {
            "kind": "function",
            "name": "extract_text",
            "signature": "llm.extract_text(response)",
            "source": "builtin:llm",
            "line": 15
          },
          {
            "kind": "function",
            "name": "extract_json",
            "signature": "llm.extract_json(response, [schema])",
            "source": "builtin:llm",
            "line": 16
          },
          {
            "kind": "function",
            "name": "usage",
            "signature": "llm.usage(response)",
            "source": "builtin:llm",
            "line": 17
          },
          {
            "kind": "function",
            "name": "cost",
            "signature": "llm.cost(response, pricing)",
            "source": "builtin:llm",
            "line": 18
          },
          {
            "kind": "function",
            "name": "budget",
            "signature": "llm.budget(response, pricing, limit)",
            "source": "builtin:llm",
            "line": 19
          },
          {
            "kind": "function",
            "name": "tool_calls",
            "signature": "llm.tool_calls(response)",
            "source": "builtin:llm",
            "line": 20
          },
          {
            "kind": "function",
            "name": "tool_result",
            "signature": "llm.tool_result(call_or_id, result)",
            "source": "builtin:llm",
            "line": 21
          },
          {
            "kind": "function",
            "name": "run_tools",
            "signature": "llm.run_tools(response, policy)",
            "source": "builtin:llm",
            "line": 22
          },
          {
            "kind": "function",
            "name": "next_messages",
            "signature": "llm.next_messages(messages, response, policy)",
            "source": "builtin:llm",
            "line": 23
          },
          {
            "kind": "function",
            "name": "next_request",
            "signature": "llm.next_request(model, messages, response, policy, tool_names, [temperature])",
            "source": "builtin:llm",
            "line": 24
          },
          {
            "kind": "function",
            "name": "next_request_json",
            "signature": "llm.next_request_json(model, messages, response, policy, tool_names, [temperature])",
            "source": "builtin:llm",
            "line": 25
          },
          {
            "kind": "function",
            "name": "next_schema_request",
            "signature": "llm.next_schema_request(model, messages, response, policy, tool_names, schema, [temperature], [name], [strict])",
            "source": "builtin:llm",
            "line": 26
          },
          {
            "kind": "function",
            "name": "next_schema_request_json",
            "signature": "llm.next_schema_request_json(model, messages, response, policy, tool_names, schema, [temperature], [name], [strict])",
            "source": "builtin:llm",
            "line": 27
          },
          {
            "kind": "function",
            "name": "stream_text",
            "signature": "llm.stream_text(sse_or_chunks)",
            "source": "builtin:llm",
            "line": 28
          },
          {
            "kind": "function",
            "name": "chat",
            "signature": "llm.chat(endpoint, api_key, model, messages, [temperature])",
            "source": "builtin:llm",
            "line": 29
          },
          {
            "kind": "function",
            "name": "chat_request",
            "signature": "llm.chat_request(endpoint, api_key, request)",
            "source": "builtin:llm",
            "line": 30
          }
        ],
        "description": "model HTTP request 조립, schema, tool call, usage·cost 처리",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "log",
        "symbol_count": 10,
        "symbols": [
          {
            "kind": "function",
            "name": "set_file",
            "signature": "log.set_file(path, [append])",
            "source": "builtin:log",
            "line": 1
          },
          {
            "kind": "function",
            "name": "set_json",
            "signature": "log.set_json(enabled)",
            "source": "builtin:log",
            "line": 2
          },
          {
            "kind": "function",
            "name": "set_level",
            "signature": "log.set_level(level)",
            "source": "builtin:log",
            "line": 3
          },
          {
            "kind": "function",
            "name": "get_level",
            "signature": "log.get_level()",
            "source": "builtin:log",
            "line": 4
          },
          {
            "kind": "function",
            "name": "level",
            "signature": "log.level([level])",
            "source": "builtin:log",
            "line": 5
          },
          {
            "kind": "function",
            "name": "event",
            "signature": "log.event(level, message, [fields])",
            "source": "builtin:log",
            "line": 6
          },
          {
            "kind": "function",
            "name": "debug",
            "signature": "log.debug(message)",
            "source": "builtin:log",
            "line": 7
          },
          {
            "kind": "function",
            "name": "info",
            "signature": "log.info(message)",
            "source": "builtin:log",
            "line": 8
          },
          {
            "kind": "function",
            "name": "warn",
            "signature": "log.warn(message)",
            "source": "builtin:log",
            "line": 9
          },
          {
            "kind": "function",
            "name": "error",
            "signature": "log.error(message)",
            "source": "builtin:log",
            "line": 10
          }
        ],
        "description": "level, text/JSON event, file output",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "math",
        "symbol_count": 14,
        "symbols": [
          {
            "kind": "function",
            "name": "sqrt",
            "signature": "math.sqrt(value)",
            "source": "builtin:math",
            "line": 1
          },
          {
            "kind": "function",
            "name": "sin",
            "signature": "math.sin(value)",
            "source": "builtin:math",
            "line": 2
          },
          {
            "kind": "function",
            "name": "cos",
            "signature": "math.cos(value)",
            "source": "builtin:math",
            "line": 3
          },
          {
            "kind": "function",
            "name": "tan",
            "signature": "math.tan(value)",
            "source": "builtin:math",
            "line": 4
          },
          {
            "kind": "function",
            "name": "floor",
            "signature": "math.floor(value)",
            "source": "builtin:math",
            "line": 5
          },
          {
            "kind": "function",
            "name": "ceil",
            "signature": "math.ceil(value)",
            "source": "builtin:math",
            "line": 6
          },
          {
            "kind": "function",
            "name": "round",
            "signature": "math.round(value)",
            "source": "builtin:math",
            "line": 7
          },
          {
            "kind": "function",
            "name": "abs",
            "signature": "math.abs(value)",
            "source": "builtin:math",
            "line": 8
          },
          {
            "kind": "function",
            "name": "sign",
            "signature": "math.sign(value)",
            "source": "builtin:math",
            "line": 9
          },
          {
            "kind": "function",
            "name": "pow",
            "signature": "math.pow(base, exponent)",
            "source": "builtin:math",
            "line": 10
          },
          {
            "kind": "function",
            "name": "min",
            "signature": "math.min(value, ...)",
            "source": "builtin:math",
            "line": 11
          },
          {
            "kind": "function",
            "name": "max",
            "signature": "math.max(value, ...)",
            "source": "builtin:math",
            "line": 12
          },
          {
            "kind": "function",
            "name": "clamp",
            "signature": "math.clamp(value, min, max)",
            "source": "builtin:math",
            "line": 13
          },
          {
            "kind": "function",
            "name": "random",
            "signature": "math.random([max]) | math.random(min, max)",
            "source": "builtin:math",
            "line": 14
          }
        ],
        "description": "수학 함수, clamp, min/max, 난수",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "nn",
        "symbol_count": 13,
        "symbols": [
          {
            "kind": "function",
            "name": "mlp",
            "signature": "nn.mlp(layer_sizes, [options])",
            "source": "builtin:nn",
            "line": 1
          },
          {
            "kind": "function",
            "name": "forward",
            "signature": "nn.forward(model, inputs)",
            "source": "builtin:nn",
            "line": 2
          },
          {
            "kind": "function",
            "name": "predict",
            "signature": "nn.predict(model, inputs)",
            "source": "builtin:nn",
            "line": 3
          },
          {
            "kind": "function",
            "name": "train",
            "signature": "nn.train(model, inputs, targets, [options])",
            "source": "builtin:nn",
            "line": 4
          },
          {
            "kind": "function",
            "name": "classify",
            "signature": "nn.classify(model, inputs, [threshold])",
            "source": "builtin:nn",
            "line": 5
          },
          {
            "kind": "function",
            "name": "evaluate",
            "signature": "nn.evaluate(model, inputs, targets, [options])",
            "source": "builtin:nn",
            "line": 6
          },
          {
            "kind": "function",
            "name": "summary",
            "signature": "nn.summary(model)",
            "source": "builtin:nn",
            "line": 7
          },
          {
            "kind": "function",
            "name": "one_hot",
            "signature": "nn.one_hot(labels, class_count)",
            "source": "builtin:nn",
            "line": 8
          },
          {
            "kind": "function",
            "name": "fit_standardizer",
            "signature": "nn.fit_standardizer(inputs)",
            "source": "builtin:nn",
            "line": 9
          },
          {
            "kind": "function",
            "name": "standardize",
            "signature": "nn.standardize(inputs, standardizer)",
            "source": "builtin:nn",
            "line": 10
          },
          {
            "kind": "function",
            "name": "split",
            "signature": "nn.split(inputs, targets, [options])",
            "source": "builtin:nn",
            "line": 11
          },
          {
            "kind": "function",
            "name": "save",
            "signature": "nn.save(model, path)",
            "source": "builtin:nn",
            "line": 12
          },
          {
            "kind": "function",
            "name": "load",
            "signature": "nn.load(path)",
            "source": "builtin:nn",
            "line": 13
          }
        ],
        "description": "CPU dense MLP 생성·학습·평가·JSON 저장",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "os",
        "symbol_count": 22,
        "symbols": [
          {
            "kind": "function",
            "name": "env_get",
            "signature": "os.env_get(name, [default])",
            "source": "builtin:os",
            "line": 1
          },
          {
            "kind": "function",
            "name": "env_require",
            "signature": "os.env_require(name)",
            "source": "builtin:os",
            "line": 2
          },
          {
            "kind": "function",
            "name": "env_set",
            "signature": "os.env_set(name, value)",
            "source": "builtin:os",
            "line": 3
          },
          {
            "kind": "function",
            "name": "env_load",
            "signature": "os.env_load(path, [override])",
            "source": "builtin:os",
            "line": 4
          },
          {
            "kind": "function",
            "name": "argv",
            "signature": "os.argv()",
            "source": "builtin:os",
            "line": 5
          },
          {
            "kind": "function",
            "name": "argc",
            "signature": "os.argc()",
            "source": "builtin:os",
            "line": 6
          },
          {
            "kind": "function",
            "name": "script_name",
            "signature": "os.script_name()",
            "source": "builtin:os",
            "line": 7
          },
          {
            "kind": "function",
            "name": "cwd",
            "signature": "os.cwd()",
            "source": "builtin:os",
            "line": 8
          },
          {
            "kind": "function",
            "name": "home_dir",
            "signature": "os.home_dir()",
            "source": "builtin:os",
            "line": 9
          },
          {
            "kind": "function",
            "name": "temp_dir",
            "signature": "os.temp_dir()",
            "source": "builtin:os",
            "line": 10
          },
          {
            "kind": "function",
            "name": "path_separator",
            "signature": "os.path_separator()",
            "source": "builtin:os",
            "line": 11
          },
          {
            "kind": "function",
            "name": "name",
            "signature": "os.name()",
            "source": "builtin:os",
            "line": 12
          },
          {
            "kind": "function",
            "name": "is_windows",
            "signature": "os.is_windows()",
            "source": "builtin:os",
            "line": 13
          },
          {
            "kind": "function",
            "name": "which",
            "signature": "os.which(command)",
            "source": "builtin:os",
            "line": 14
          },
          {
            "kind": "function",
            "name": "cmd_exists",
            "signature": "os.cmd_exists(command)",
            "source": "builtin:os",
            "line": 15
          },
          {
            "kind": "function",
            "name": "cmd_quote",
            "signature": "os.cmd_quote(text)",
            "source": "builtin:os",
            "line": 16
          },
          {
            "kind": "function",
            "name": "cmd_join",
            "signature": "os.cmd_join(args)",
            "source": "builtin:os",
            "line": 17
          },
          {
            "kind": "function",
            "name": "run",
            "signature": "os.run(command)",
            "source": "builtin:os",
            "line": 18
          },
          {
            "kind": "function",
            "name": "run_checked",
            "signature": "os.run_checked(command)",
            "source": "builtin:os",
            "line": 19
          },
          {
            "kind": "function",
            "name": "cmd",
            "signature": "os.cmd(command)",
            "source": "builtin:os",
            "line": 20
          },
          {
            "kind": "function",
            "name": "sleep_ms",
            "signature": "os.sleep_ms(milliseconds)",
            "source": "builtin:os",
            "line": 21
          },
          {
            "kind": "function",
            "name": "wait",
            "signature": "os.wait(milliseconds)",
            "source": "builtin:os",
            "line": 22
          }
        ],
        "description": "환경 변수, argv, 경로, command 실행, sleep",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "path",
        "symbol_count": 8,
        "symbols": [
          {
            "kind": "function",
            "name": "join",
            "signature": "path.join(part, ...)",
            "source": "builtin:path",
            "line": 1
          },
          {
            "kind": "function",
            "name": "basename",
            "signature": "path.basename(path)",
            "source": "builtin:path",
            "line": 2
          },
          {
            "kind": "function",
            "name": "dirname",
            "signature": "path.dirname(path)",
            "source": "builtin:path",
            "line": 3
          },
          {
            "kind": "function",
            "name": "ext",
            "signature": "path.ext(path)",
            "source": "builtin:path",
            "line": 4
          },
          {
            "kind": "function",
            "name": "stem",
            "signature": "path.stem(path)",
            "source": "builtin:path",
            "line": 5
          },
          {
            "kind": "function",
            "name": "normalize",
            "signature": "path.normalize(path)",
            "source": "builtin:path",
            "line": 6
          },
          {
            "kind": "function",
            "name": "abs",
            "signature": "path.abs(path)",
            "source": "builtin:path",
            "line": 7
          },
          {
            "kind": "function",
            "name": "relative",
            "signature": "path.relative(path, [base])",
            "source": "builtin:path",
            "line": 8
          }
        ],
        "description": "경로 결합·정규화·상대/절대 경로",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "media",
        "symbol_count": 6,
        "symbols": [
          {
            "kind": "function",
            "name": "available",
            "signature": "media.available([ffmpeg_path])",
            "source": "builtin:media",
            "line": 1
          },
          {
            "kind": "function",
            "name": "ffmpeg_available",
            "signature": "media.ffmpeg_available([ffmpeg_path])",
            "source": "builtin:media",
            "line": 2
          },
          {
            "kind": "function",
            "name": "frame_to_text",
            "signature": "media.frame_to_text(pixels, [options])",
            "source": "builtin:media",
            "line": 3
          },
          {
            "kind": "function",
            "name": "ascii_frames",
            "signature": "media.ascii_frames(path, [options])",
            "source": "builtin:media",
            "line": 4
          },
          {
            "kind": "function",
            "name": "video_to_text",
            "signature": "media.video_to_text(path, [options])",
            "source": "builtin:media",
            "line": 5
          },
          {
            "kind": "function",
            "name": "video_text_frames",
            "signature": "media.video_text_frames(path, [options])",
            "source": "builtin:media",
            "line": 6
          }
        ],
        "description": "픽셀과 로컬 영상을 문자 프레임으로 변환",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "plugin",
        "symbol_count": 5,
        "symbols": [
          {
            "kind": "function",
            "name": "load",
            "signature": "plugin.load(path)",
            "source": "builtin:plugin",
            "line": 1
          },
          {
            "kind": "function",
            "name": "load_manifest",
            "signature": "plugin.load_manifest(path)",
            "source": "builtin:plugin",
            "line": 2
          },
          {
            "kind": "function",
            "name": "call",
            "signature": "plugin.call(plugin, export, ...args)",
            "source": "builtin:plugin",
            "line": 3
          },
          {
            "kind": "function",
            "name": "info",
            "signature": "plugin.info(plugin)",
            "source": "builtin:plugin",
            "line": 4
          },
          {
            "kind": "function",
            "name": "unload",
            "signature": "plugin.unload(plugin)",
            "source": "builtin:plugin",
            "line": 5
          }
        ],
        "description": "Sura plugin ABI library load·call·lifecycle",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "python",
        "symbol_count": 5,
        "symbols": [
          {
            "kind": "function",
            "name": "available",
            "signature": "python.available()",
            "source": "builtin:python",
            "line": 1
          },
          {
            "kind": "function",
            "name": "executable",
            "signature": "python.executable()",
            "source": "builtin:python",
            "line": 2
          },
          {
            "kind": "function",
            "name": "eval",
            "signature": "python.eval(code)",
            "source": "builtin:python",
            "line": 3
          },
          {
            "kind": "function",
            "name": "call",
            "signature": "python.call(module, function, [args], [kwargs])",
            "source": "builtin:python",
            "line": 4
          },
          {
            "kind": "function",
            "name": "call_json",
            "signature": "python.call_json(module, function, [args], [kwargs])",
            "source": "builtin:python",
            "line": 5
          }
        ],
        "description": "선택형 Python interpreter 탐색·eval·module call",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "rag",
        "symbol_count": 4,
        "symbols": [
          {
            "kind": "function",
            "name": "context",
            "signature": "rag.context(query, docs, [k], [embedding_field], [text_field])",
            "source": "builtin:rag",
            "line": 1
          },
          {
            "kind": "function",
            "name": "sources",
            "signature": "rag.sources(query, docs, [k], [embedding_field], [text_field], [title_field])",
            "source": "builtin:rag",
            "line": 2
          },
          {
            "kind": "function",
            "name": "prepare",
            "signature": "rag.prepare(question, query, docs, [k], [embedding_field], [text_field], [system], [title_field])",
            "source": "builtin:rag",
            "line": 3
          },
          {
            "kind": "function",
            "name": "messages",
            "signature": "rag.messages(question, context, [system])",
            "source": "builtin:rag",
            "line": 4
          }
        ],
        "description": "검색 결과를 context·source·message 형태로 조립",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "random",
        "symbol_count": 8,
        "symbols": [
          {
            "kind": "function",
            "name": "seed",
            "signature": "random.seed(seed)",
            "source": "builtin:random",
            "line": 1
          },
          {
            "kind": "function",
            "name": "int",
            "signature": "random.int(max) | random.int(min, max)",
            "source": "builtin:random",
            "line": 2
          },
          {
            "kind": "function",
            "name": "float",
            "signature": "random.float([max]) | random.float(min, max)",
            "source": "builtin:random",
            "line": 3
          },
          {
            "kind": "function",
            "name": "bool",
            "signature": "random.bool([probability])",
            "source": "builtin:random",
            "line": 4
          },
          {
            "kind": "function",
            "name": "choice",
            "signature": "random.choice(array)",
            "source": "builtin:random",
            "line": 5
          },
          {
            "kind": "function",
            "name": "shuffle",
            "signature": "random.shuffle(array)",
            "source": "builtin:random",
            "line": 6
          },
          {
            "kind": "function",
            "name": "bytes",
            "signature": "random.bytes(count)",
            "source": "builtin:random",
            "line": 7
          },
          {
            "kind": "function",
            "name": "uuid",
            "signature": "random.uuid()",
            "source": "builtin:random",
            "line": 8
          }
        ],
        "description": "seed 기반 숫자·선택·shuffle·bytes·UUID",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "regex",
        "symbol_count": 7,
        "symbols": [
          {
            "kind": "function",
            "name": "match",
            "signature": "regex.match(text, pattern)",
            "source": "builtin:regex",
            "line": 1
          },
          {
            "kind": "function",
            "name": "replace",
            "signature": "regex.replace(text, pattern, replacement)",
            "source": "builtin:regex",
            "line": 2
          },
          {
            "kind": "function",
            "name": "find_all",
            "signature": "regex.find_all(text, pattern)",
            "source": "builtin:regex",
            "line": 3
          },
          {
            "kind": "function",
            "name": "escape",
            "signature": "regex.escape(text)",
            "source": "builtin:regex",
            "line": 4
          },
          {
            "kind": "function",
            "name": "capture",
            "signature": "regex.capture(text, pattern)",
            "source": "builtin:regex",
            "line": 5
          },
          {
            "kind": "function",
            "name": "captures",
            "signature": "regex.captures(text, pattern)",
            "source": "builtin:regex",
            "line": 6
          },
          {
            "kind": "function",
            "name": "split",
            "signature": "regex.split(text, pattern)",
            "source": "builtin:regex",
            "line": 7
          }
        ],
        "description": "정규식 match·replace·capture·split",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "set",
        "symbol_count": 6,
        "symbols": [
          {
            "kind": "function",
            "name": "union",
            "signature": "set.union(array, ...)",
            "source": "builtin:set",
            "line": 1
          },
          {
            "kind": "function",
            "name": "intersection",
            "signature": "set.intersection(array, ...)",
            "source": "builtin:set",
            "line": 2
          },
          {
            "kind": "function",
            "name": "difference",
            "signature": "set.difference(array, ...)",
            "source": "builtin:set",
            "line": 3
          },
          {
            "kind": "function",
            "name": "symmetric_difference",
            "signature": "set.symmetric_difference(left, right)",
            "source": "builtin:set",
            "line": 4
          },
          {
            "kind": "function",
            "name": "is_subset",
            "signature": "set.is_subset(left, right)",
            "source": "builtin:set",
            "line": 5
          },
          {
            "kind": "function",
            "name": "is_superset",
            "signature": "set.is_superset(left, right)",
            "source": "builtin:set",
            "line": 6
          }
        ],
        "description": "배열 기반 합집합·교집합·차집합",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "stream",
        "symbol_count": 14,
        "symbols": [
          {
            "kind": "function",
            "name": "from",
            "signature": "stream.from(array_or_text)",
            "source": "builtin:stream",
            "line": 1
          },
          {
            "kind": "function",
            "name": "next",
            "signature": "stream.next(stream)",
            "source": "builtin:stream",
            "line": 2
          },
          {
            "kind": "function",
            "name": "collect",
            "signature": "stream.collect(stream)",
            "source": "builtin:stream",
            "line": 3
          },
          {
            "kind": "function",
            "name": "take",
            "signature": "stream.take(stream, count)",
            "source": "builtin:stream",
            "line": 4
          },
          {
            "kind": "function",
            "name": "batch",
            "signature": "stream.batch(stream, size)",
            "source": "builtin:stream",
            "line": 5
          },
          {
            "kind": "function",
            "name": "map",
            "signature": "stream.map(stream, path, [fallback])",
            "source": "builtin:stream",
            "line": 6
          },
          {
            "kind": "function",
            "name": "filter",
            "signature": "stream.filter(stream, criteria)",
            "source": "builtin:stream",
            "line": 7
          },
          {
            "kind": "function",
            "name": "window",
            "signature": "stream.window(stream, size, [step])",
            "source": "builtin:stream",
            "line": 8
          },
          {
            "kind": "function",
            "name": "skip",
            "signature": "stream.skip(stream, count)",
            "source": "builtin:stream",
            "line": 9
          },
          {
            "kind": "function",
            "name": "count",
            "signature": "stream.count(stream)",
            "source": "builtin:stream",
            "line": 10
          },
          {
            "kind": "function",
            "name": "join",
            "signature": "stream.join(stream, [separator])",
            "source": "builtin:stream",
            "line": 11
          },
          {
            "kind": "function",
            "name": "sum",
            "signature": "stream.sum(stream, [path])",
            "source": "builtin:stream",
            "line": 12
          },
          {
            "kind": "function",
            "name": "avg",
            "signature": "stream.avg(stream, [path])",
            "source": "builtin:stream",
            "line": 13
          },
          {
            "kind": "function",
            "name": "lines",
            "signature": "stream.lines(path)",
            "source": "builtin:stream",
            "line": 14
          }
        ],
        "description": "lazy stream map·filter·window·batch·집계",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "string",
        "symbol_count": 20,
        "symbols": [
          {
            "kind": "function",
            "name": "len",
            "signature": "string.len(text)",
            "source": "builtin:string",
            "line": 1
          },
          {
            "kind": "function",
            "name": "length",
            "signature": "string.length(text)",
            "source": "builtin:string",
            "line": 2
          },
          {
            "kind": "function",
            "name": "size",
            "signature": "string.size(text)",
            "source": "builtin:string",
            "line": 3
          },
          {
            "kind": "function",
            "name": "split",
            "signature": "string.split(text, separator)",
            "source": "builtin:string",
            "line": 4
          },
          {
            "kind": "function",
            "name": "join",
            "signature": "string.join(array, separator)",
            "source": "builtin:string",
            "line": 5
          },
          {
            "kind": "function",
            "name": "trim",
            "signature": "string.trim(text)",
            "source": "builtin:string",
            "line": 6
          },
          {
            "kind": "function",
            "name": "upper",
            "signature": "string.upper(text)",
            "source": "builtin:string",
            "line": 7
          },
          {
            "kind": "function",
            "name": "lower",
            "signature": "string.lower(text)",
            "source": "builtin:string",
            "line": 8
          },
          {
            "kind": "function",
            "name": "contains",
            "signature": "string.contains(text, needle)",
            "source": "builtin:string",
            "line": 9
          },
          {
            "kind": "function",
            "name": "starts_with",
            "signature": "string.starts_with(text, prefix)",
            "source": "builtin:string",
            "line": 10
          },
          {
            "kind": "function",
            "name": "ends_with",
            "signature": "string.ends_with(text, suffix)",
            "source": "builtin:string",
            "line": 11
          },
          {
            "kind": "function",
            "name": "index_of",
            "signature": "string.index_of(text, needle)",
            "source": "builtin:string",
            "line": 12
          },
          {
            "kind": "function",
            "name": "sub",
            "signature": "string.sub(text, start, [end])",
            "source": "builtin:string",
            "line": 13
          },
          {
            "kind": "function",
            "name": "replace",
            "signature": "string.replace(text, from, to)",
            "source": "builtin:string",
            "line": 14
          },
          {
            "kind": "function",
            "name": "lines",
            "signature": "string.lines(text)",
            "source": "builtin:string",
            "line": 15
          },
          {
            "kind": "function",
            "name": "words",
            "signature": "string.words(text)",
            "source": "builtin:string",
            "line": 16
          },
          {
            "kind": "function",
            "name": "repeat",
            "signature": "string.repeat(text, count)",
            "source": "builtin:string",
            "line": 17
          },
          {
            "kind": "function",
            "name": "pad_left",
            "signature": "string.pad_left(text, width, [fill])",
            "source": "builtin:string",
            "line": 18
          },
          {
            "kind": "function",
            "name": "pad_right",
            "signature": "string.pad_right(text, width, [fill])",
            "source": "builtin:string",
            "line": 19
          },
          {
            "kind": "function",
            "name": "chunks",
            "signature": "string.chunks(text, [max_chars], [overlap])",
            "source": "builtin:string",
            "line": 20
          }
        ],
        "description": "문자열 길이·분할·검색·치환·padding·chunk",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "tensor",
        "symbol_count": 19,
        "symbols": [
          {
            "kind": "function",
            "name": "shape",
            "signature": "tensor.shape(tensor)",
            "source": "builtin:tensor",
            "line": 1
          },
          {
            "kind": "function",
            "name": "zeros",
            "signature": "tensor.zeros(shape)",
            "source": "builtin:tensor",
            "line": 2
          },
          {
            "kind": "function",
            "name": "fill",
            "signature": "tensor.fill(shape, value)",
            "source": "builtin:tensor",
            "line": 3
          },
          {
            "kind": "function",
            "name": "add",
            "signature": "tensor.add(a, b)",
            "source": "builtin:tensor",
            "line": 4
          },
          {
            "kind": "function",
            "name": "mul",
            "signature": "tensor.mul(a, b)",
            "source": "builtin:tensor",
            "line": 5
          },
          {
            "kind": "function",
            "name": "clip",
            "signature": "tensor.clip(tensor, min, max)",
            "source": "builtin:tensor",
            "line": 6
          },
          {
            "kind": "function",
            "name": "flatten",
            "signature": "tensor.flatten(tensor)",
            "source": "builtin:tensor",
            "line": 7
          },
          {
            "kind": "function",
            "name": "sum",
            "signature": "tensor.sum(tensor)",
            "source": "builtin:tensor",
            "line": 8
          },
          {
            "kind": "function",
            "name": "mean",
            "signature": "tensor.mean(tensor)",
            "source": "builtin:tensor",
            "line": 9
          },
          {
            "kind": "function",
            "name": "variance",
            "signature": "tensor.variance(tensor)",
            "source": "builtin:tensor",
            "line": 10
          },
          {
            "kind": "function",
            "name": "std",
            "signature": "tensor.std(tensor)",
            "source": "builtin:tensor",
            "line": 11
          },
          {
            "kind": "function",
            "name": "min",
            "signature": "tensor.min(tensor)",
            "source": "builtin:tensor",
            "line": 12
          },
          {
            "kind": "function",
            "name": "max",
            "signature": "tensor.max(tensor)",
            "source": "builtin:tensor",
            "line": 13
          },
          {
            "kind": "function",
            "name": "argmin",
            "signature": "tensor.argmin(tensor)",
            "source": "builtin:tensor",
            "line": 14
          },
          {
            "kind": "function",
            "name": "argmax",
            "signature": "tensor.argmax(tensor)",
            "source": "builtin:tensor",
            "line": 15
          },
          {
            "kind": "function",
            "name": "zscore",
            "signature": "tensor.zscore(tensor)",
            "source": "builtin:tensor",
            "line": 16
          },
          {
            "kind": "function",
            "name": "softmax",
            "signature": "tensor.softmax(tensor)",
            "source": "builtin:tensor",
            "line": 17
          },
          {
            "kind": "function",
            "name": "transpose",
            "signature": "tensor.transpose(matrix)",
            "source": "builtin:tensor",
            "line": 18
          },
          {
            "kind": "function",
            "name": "matmul",
            "signature": "tensor.matmul(a, b)",
            "source": "builtin:tensor",
            "line": 19
          }
        ],
        "description": "일반 배열 기반 tensor 연산과 통계",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "test",
        "symbol_count": 16,
        "symbols": [
          {
            "kind": "function",
            "name": "assert",
            "signature": "test.assert(condition, [message])",
            "source": "builtin:test",
            "line": 1
          },
          {
            "kind": "function",
            "name": "eq",
            "signature": "test.eq(actual, expected, [message])",
            "source": "builtin:test",
            "line": 2
          },
          {
            "kind": "function",
            "name": "ne",
            "signature": "test.ne(actual, expected, [message])",
            "source": "builtin:test",
            "line": 3
          },
          {
            "kind": "function",
            "name": "neq",
            "signature": "test.neq(actual, expected, [message])",
            "source": "builtin:test",
            "line": 4
          },
          {
            "kind": "function",
            "name": "contains",
            "signature": "test.contains(container, value, [message])",
            "source": "builtin:test",
            "line": 5
          },
          {
            "kind": "function",
            "name": "not_contains",
            "signature": "test.not_contains(container, value, [message])",
            "source": "builtin:test",
            "line": 6
          },
          {
            "kind": "function",
            "name": "match",
            "signature": "test.match(text, pattern, [message])",
            "source": "builtin:test",
            "line": 7
          },
          {
            "kind": "function",
            "name": "type",
            "signature": "test.type(value, type, [message])",
            "source": "builtin:test",
            "line": 8
          },
          {
            "kind": "function",
            "name": "len",
            "signature": "test.len(value, length, [message])",
            "source": "builtin:test",
            "line": 9
          },
          {
            "kind": "function",
            "name": "between",
            "signature": "test.between(value, min, max, [message])",
            "source": "builtin:test",
            "line": 10
          },
          {
            "kind": "function",
            "name": "approx",
            "signature": "test.approx(actual, expected, [epsilon], [message])",
            "source": "builtin:test",
            "line": 11
          },
          {
            "kind": "function",
            "name": "check",
            "signature": "test.check(name, condition, [message])",
            "source": "builtin:test",
            "line": 12
          },
          {
            "kind": "function",
            "name": "check_eq",
            "signature": "test.check_eq(name, actual, expected, [message])",
            "source": "builtin:test",
            "line": 13
          },
          {
            "kind": "function",
            "name": "check_match",
            "signature": "test.check_match(name, text, pattern, [message])",
            "source": "builtin:test",
            "line": 14
          },
          {
            "kind": "function",
            "name": "summary",
            "signature": "test.summary(results)",
            "source": "builtin:test",
            "line": 15
          },
          {
            "kind": "function",
            "name": "report",
            "signature": "test.report(results, [title])",
            "source": "builtin:test",
            "line": 16
          }
        ],
        "description": "assertion, check, summary, report",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "tokenizer",
        "symbol_count": 7,
        "symbols": [
          {
            "kind": "function",
            "name": "byte",
            "signature": "tokenizer.byte([options])",
            "source": "builtin:tokenizer",
            "line": 1
          },
          {
            "kind": "function",
            "name": "train_bpe",
            "signature": "tokenizer.train_bpe(corpus, [options])",
            "source": "builtin:tokenizer",
            "line": 2
          },
          {
            "kind": "function",
            "name": "encode",
            "signature": "tokenizer.encode(tokenizer, text, [options])",
            "source": "builtin:tokenizer",
            "line": 3
          },
          {
            "kind": "function",
            "name": "decode",
            "signature": "tokenizer.decode(tokenizer, ids, [options])",
            "source": "builtin:tokenizer",
            "line": 4
          },
          {
            "kind": "function",
            "name": "info",
            "signature": "tokenizer.info(tokenizer)",
            "source": "builtin:tokenizer",
            "line": 5
          },
          {
            "kind": "function",
            "name": "save",
            "signature": "tokenizer.save(tokenizer, path)",
            "source": "builtin:tokenizer",
            "line": 6
          },
          {
            "kind": "function",
            "name": "load",
            "signature": "tokenizer.load(path)",
            "source": "builtin:tokenizer",
            "line": 7
          }
        ],
        "description": "UTF-8 raw-byte와 bounded byte-level BPE tokenizer, tokenizer 파일",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "tool",
        "symbol_count": 7,
        "symbols": [
          {
            "kind": "function",
            "name": "call",
            "signature": "tool.call(spec)",
            "source": "builtin:tool",
            "line": 1
          },
          {
            "kind": "function",
            "name": "spec",
            "signature": "tool.spec(name, args)",
            "source": "builtin:tool",
            "line": 2
          },
          {
            "kind": "function",
            "name": "validate",
            "signature": "tool.validate(spec)",
            "source": "builtin:tool",
            "line": 3
          },
          {
            "kind": "function",
            "name": "schema",
            "signature": "tool.schema(name)",
            "source": "builtin:tool",
            "line": 4
          },
          {
            "kind": "function",
            "name": "allowed",
            "signature": "tool.allowed(spec, policy)",
            "source": "builtin:tool",
            "line": 5
          },
          {
            "kind": "function",
            "name": "call_policy",
            "signature": "tool.call_policy(spec, policy)",
            "source": "builtin:tool",
            "line": 6
          },
          {
            "kind": "function",
            "name": "list",
            "signature": "tool.list()",
            "source": "builtin:tool",
            "line": 7
          }
        ],
        "description": "도구 schema·policy 검사와 호출",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      },
      {
        "name": "vector",
        "symbol_count": 24,
        "symbols": [
          {
            "kind": "function",
            "name": "vec3",
            "signature": "vector.vec3(x, y, z)",
            "source": "builtin:vector",
            "line": 1
          },
          {
            "kind": "function",
            "name": "add",
            "signature": "vector.add(a, b)",
            "source": "builtin:vector",
            "line": 2
          },
          {
            "kind": "function",
            "name": "dot",
            "signature": "vector.dot(a, b)",
            "source": "builtin:vector",
            "line": 3
          },
          {
            "kind": "function",
            "name": "scale",
            "signature": "vector.scale(vector, scalar)",
            "source": "builtin:vector",
            "line": 4
          },
          {
            "kind": "function",
            "name": "norm",
            "signature": "vector.norm(vector)",
            "source": "builtin:vector",
            "line": 5
          },
          {
            "kind": "function",
            "name": "add3",
            "signature": "vector.add3(a, b)",
            "source": "builtin:vector",
            "line": 6
          },
          {
            "kind": "function",
            "name": "sub3",
            "signature": "vector.sub3(a, b)",
            "source": "builtin:vector",
            "line": 7
          },
          {
            "kind": "function",
            "name": "dot3",
            "signature": "vector.dot3(a, b)",
            "source": "builtin:vector",
            "line": 8
          },
          {
            "kind": "function",
            "name": "cross",
            "signature": "vector.cross(a, b)",
            "source": "builtin:vector",
            "line": 9
          },
          {
            "kind": "function",
            "name": "scale3",
            "signature": "vector.scale3(vector, scalar)",
            "source": "builtin:vector",
            "line": 10
          },
          {
            "kind": "function",
            "name": "norm3",
            "signature": "vector.norm3(vector)",
            "source": "builtin:vector",
            "line": 11
          },
          {
            "kind": "function",
            "name": "normalize3",
            "signature": "vector.normalize3(vector)",
            "source": "builtin:vector",
            "line": 12
          },
          {
            "kind": "function",
            "name": "distance3",
            "signature": "vector.distance3(a, b)",
            "source": "builtin:vector",
            "line": 13
          },
          {
            "kind": "function",
            "name": "neg3",
            "signature": "vector.neg3(vector)",
            "source": "builtin:vector",
            "line": 14
          },
          {
            "kind": "function",
            "name": "lerp3",
            "signature": "vector.lerp3(a, b, t)",
            "source": "builtin:vector",
            "line": 15
          },
          {
            "kind": "function",
            "name": "midpoint3",
            "signature": "vector.midpoint3(a, b)",
            "source": "builtin:vector",
            "line": 16
          },
          {
            "kind": "function",
            "name": "project3",
            "signature": "vector.project3(vector, onto)",
            "source": "builtin:vector",
            "line": 17
          },
          {
            "kind": "function",
            "name": "reject3",
            "signature": "vector.reject3(vector, onto)",
            "source": "builtin:vector",
            "line": 18
          },
          {
            "kind": "function",
            "name": "reflect3",
            "signature": "vector.reflect3(vector, normal)",
            "source": "builtin:vector",
            "line": 19
          },
          {
            "kind": "function",
            "name": "angle3",
            "signature": "vector.angle3(a, b)",
            "source": "builtin:vector",
            "line": 20
          },
          {
            "kind": "function",
            "name": "transform4",
            "signature": "vector.transform4(vector, matrix4)",
            "source": "builtin:vector",
            "line": 21
          },
          {
            "kind": "function",
            "name": "cosine",
            "signature": "vector.cosine(a, b)",
            "source": "builtin:vector",
            "line": 22
          },
          {
            "kind": "function",
            "name": "normalize",
            "signature": "vector.normalize(vector)",
            "source": "builtin:vector",
            "line": 23
          },
          {
            "kind": "function",
            "name": "search",
            "signature": "vector.search(query, rows, [k], [field])",
            "source": "builtin:vector",
            "line": 24
          }
        ],
        "description": "2D/3D vector, cosine, normalize, transform, search",
        "documentation_scope": "signature and source location; return and error contracts are present only when encoded by the signature or prose sections"
      }
    ]
  },
  "async": {
    "default_workers": "hardware concurrency clamped to 1..8; fallback 4",
    "default_max_queue": 1024,
    "configurable_worker_range": "1..256",
    "configurable_queue_range": "1..1000000",
    "task_states": [
      "queued",
      "running",
      "succeeded",
      "failed",
      "cancelled"
    ],
    "task_kinds": [
      "command",
      "HTTP request",
      "timer",
      "isolated Sura program"
    ],
    "closure_spawn": false,
    "sura_program_task": {
      "call": "async.sura({program, input, timeout_ms?}, optional_scope)",
      "isolation": "child Sura process; no closure, instance, tensor, native resource, or Value pointer is shared",
      "program_extensions": [
        ".sura",
        ".sura.bc",
        ".bc",
        ".sura.srp",
        ".srp"
      ],
      "program_snapshot_limit_bytes": 67108864,
      "input_format": "JSON-safe nil, bool, finite number, string, array, and dict",
      "input_limit_bytes": 67108864,
      "input_node_limit": 1000000,
      "input_depth_limit": 128,
      "rejected_input": [
        "closure",
        "instance",
        "tensor",
        "native resource",
        "cycle"
      ],
      "alias_identity_preserved": false,
      "default_timeout_ms": 30000,
      "timeout_range_ms": [
        1,
        3600000
      ],
      "child_input": "argv()[0] contains the JSON input snapshot",
      "result": "captured child stdout returned by await",
      "nonzero_exit": "task fails",
      "recursive_child_async_sura": false,
      "cleanup": "temporary program/input files are removed after success, failure, timeout, cancellation, and runtime shutdown"
    },
    "structured_scopes": true,
    "wait_strategy": "completion epoch and condition variable; any/all_timeout do not poll",
    "queued_cancellation": "removes the task from the FIFO queue in O(1)",
    "result_limit_bytes": 67108864,
    "retained_result_budget_bytes": 268435456,
    "retained_error_limit_bytes": 65536,
    "retained_budget_observability": [
      "async.limits().max_retained_bytes",
      "async.limits().retained_bytes"
    ],
    "output_limit_action": "command/curl process tree is terminated and the task fails",
    "file_url_reads": "regular files only; 64 KiB chunks with cancellation checkpoints; 64 MiB result cap"
  },
  "tokenizer": {
    "byte": "lossless raw UTF-8 bytes with IDs 0..255",
    "bpe": "deterministic byte-level BPE; pair-count ties use the smallest numeric pair key",
    "bpe_training_corpus_limit_bytes": 1048576,
    "bpe_vocabulary_range": [
      256,
      4096
    ],
    "bpe_training_work_limit_token_visits": 67108864,
    "bpe_stream_flush_bytes": 65536,
    "direct_encode_decode_limit_bytes": 16777216,
    "persistence": "byte tokenizer file v1 remains readable; BPE uses checksummed tokenizer file v2",
    "lossless_utf8": true,
    "normalization": false,
    "external_tokenizer_format_compatibility": false,
    "dataset_pack_text": "byte and BPE tokenizers; BPE retains a raw suffix as long as the largest learned piece so merges remain exact across text/file chunks",
    "verification": "tests/23_tokenizer_dataset.sura and tests/70_bpe_tokenizer.sura"
  },
  "onnx_execution": {
    "api": "autograd.run_onnx(path, inputs, [options])",
    "status": "experimental bounded CPU subset; not a general ONNX runtime",
    "device": "cpu",
    "ir_version_range": [
      3,
      10
    ],
    "default_opset_range": [
      7,
      18
    ],
    "max_nodes": 4096,
    "max_node_inputs": 16,
    "max_node_outputs": 16,
    "max_node_attributes": 64,
    "supported_operators": [
      "Identity",
      "Add",
      "Sub",
      "Mul",
      "Div",
      "Neg",
      "MatMul",
      "Relu",
      "Tanh",
      "Sigmoid",
      "Gemm",
      "Transpose",
      "Flatten",
      "Reshape",
      "Softmax on the last axis"
    ],
    "shape_operator_contract": "Transpose validates a complete perm or reverses axes by default; Flatten validates axis in [-rank, rank]; Reshape accepts only a raw-data rank-1 INT64 initializer of at most 8 values, copies axes for 0 with allowzero=0, and permits one inferred -1; all preserve the Sura autograd graph",
    "initializer_storage": "raw_data only",
    "initializer_dtypes": [
      "FLOAT",
      "FLOAT16",
      "DOUBLE",
      "BFLOAT16"
    ],
    "reshape_shape_initializer": "raw-data INT64, rank 1, 0..8 values, usable only as Reshape input 1; not exposed by load_onnx_weights",
    "topological_order_required": true,
    "declared_value_metadata": "when ValueInfo contains Tensor dtype and static shape, inputs, initializers, intermediate values, and outputs must match; symbolic dimensions are rejected",
    "gradient": "Sura autograd graph is preserved from outputs to supplied inputs",
    "rejected_or_unsupported": [
      "custom operator domains",
      "GPU inputs",
      "external data",
      "integer Tensor initializers outside bounded Reshape shapes",
      "zero-sized floating Tensor outputs",
      "Conv",
      "dynamic shapes",
      "control flow",
      "unknown operators and attributes"
    ],
    "verification": "tests/71_onnx_execution.sura"
  },
  "targets": {
    "native_vm_jit": "primary",
    "javascript": {
      "ast_node_count": 43,
      "full": 41,
      "ignored": 2,
      "partial": 0,
      "classification_complete": true,
      "runtime_parity_with_native": false,
      "native_only_or_missing_areas": [
        "Python bridge",
        "FFI",
        "plugin",
        "async.cmd",
        "autograd",
        "media",
        "nn",
        "dataset",
        "tokenizer"
      ]
    },
    "wasm": {
      "ast_node_count": 43,
      "full": 27,
      "ignored": 2,
      "partial": 14,
      "classification_complete": false,
      "runtime_parity_with_native": false
    }
  },
  "freestanding": {
    "status": "experimental compiler target with an executed QEMU graphical desktop milestone; not a complete operating system",
    "target": "uefi-x86_64",
    "output": "position-independent PE32+ EFI application",
    "hosted_runtime_dependencies": [],
    "entry_order": [
      "efi_main",
      "kernel_main",
      "main",
      "synthetic top-level entry"
    ],
    "modules": {
      "syntax": "import \"relative/path.sura\"",
      "resolution": "relative to the importing file, recursively",
      "duplicate_policy": "one inclusion per normalized path",
      "errors": [
        "missing file",
        "circular import",
        "import parse failure"
      ],
      "namespace": "one shared freestanding global namespace"
    },
    "scalar_types": [
      "i8",
      "u8",
      "i16",
      "u16",
      "i32",
      "u32",
      "i64",
      "u64",
      "isize",
      "usize",
      "ptr",
      "ptr[StructName]"
    ],
    "control_flow": [
      "signedness-aware integer comparison, division, remainder, and right shift",
      "if/while/repeat",
      "break/continue",
      "and/or short-circuit with selected-operand result"
    ],
    "integer_semantics": {
      "signed": [
        "signed comparisons",
        "signed division and remainder",
        "arithmetic right shift"
      ],
      "unsigned": [
        "unsigned comparisons",
        "unsigned division and remainder",
        "logical right shift"
      ],
      "executed_verification": [
        "examples/os/integer_semantics_qemu_gate.sura",
        "tools/sura_integer_semantics_qemu_gate.ps1",
        "0xffffffffffffffff and high-bit boundary cases",
        "negative i64 boundary cases",
        "SURA_INTEGER_SEMANTICS_OK"
      ]
    },
    "tls13_crypto": {
      "libraries": [
        "stdlib/freestanding/sha256.sura",
        "stdlib/freestanding/sha384.sura",
        "stdlib/freestanding/hkdf_sha256.sura",
        "stdlib/freestanding/aes128_gcm.sura",
        "stdlib/freestanding/x25519.sura",
        "stdlib/freestanding/tls13_record.sura",
        "stdlib/freestanding/tls13_handshake.sura",
        "stdlib/freestanding/tls13_hello.sura",
        "stdlib/freestanding/tls13_messages.sura",
        "stdlib/freestanding/tls13_verify.sura",
        "stdlib/freestanding/entropy_x86.sura",
        "stdlib/freestanding/rsa_public.sura",
        "stdlib/freestanding/rsa_sha256.sura",
        "stdlib/freestanding/rsa_sha384.sura",
        "stdlib/freestanding/der.sura",
        "stdlib/freestanding/x509.sura",
        "stdlib/freestanding/x509_chain.sura"
      ],
      "algorithms": [
        "streaming SHA-256",
        "streaming SHA-384",
        "HMAC-SHA256",
        "HKDF-Extract and HKDF-Expand",
        "TLS 1.3 HKDF-Expand-Label",
        "AES-128 block encryption",
        "AES-128-GCM with 96-bit nonce and 128-bit tag",
        "X25519 with all-zero shared-secret rejection",
        "TLS 1.3 record nonce, encryption, authenticated decryption, content-type and zero-padding recovery",
        "RFC 8448 ClientHello plus ServerHello handshake key schedule",
        "TLS 1.3 application traffic secrets and Finished calculation",
        "SNI/TLS 1.3/X25519/signature-scheme/AES-128-GCM/HTTP-1.1-ALPN ClientHello builder",
        "strict ServerHello and encrypted handshake-message parsers",
        "RDRAND-backed hardware entropy with fail-closed retry",
        "32-bit-limb Montgomery RSA public exponent 65537 operation",
        "RSA-PSS-SHA256 plus PKCS#1 v1.5 SHA-256 and SHA-384 verification",
        "bounded DER and X.509 parsing",
        "certificate chain, hostname, validity-time, key-usage, basic-constraints, and explicit trust-anchor validation"
      ],
      "storage": "caller-owned fixed buffers; no allocator, hosted runtime, OS API, or firmware service after initialization",
      "executed_gate": "tools/sura_tls_crypto_qemu_gate.ps1",
      "executed_environment": "QEMU/OVMF after ExitBootServices",
      "known_answers": [
        "RFC 6234 SHA-256 and HMAC-SHA256",
        "SHA-384 empty/abc and 111/112-byte padding-boundary vectors",
        "RFC 5869 HKDF test case 1",
        "RFC 8448 HKDF-Expand-Label finished key",
        "AES-128 known answer",
        "NIST SP 800-38D AES-128-GCM known answer",
        "RFC 7748 direct X25519 and Alice/Bob shared secret",
        "RFC 8448 encrypted TLS 1.3 application-data record",
        "RFC 8448 complete initial handshake secrets, traffic keys, IVs, and Finished keys",
        "independently generated application traffic secret, key, IV, and Finished values",
        "independent BigInteger RSA exponent-65537 result",
        "OpenSSL-generated RSA-PSS and PKCS#1 SHA-256 signatures",
        "official pinned SHA-384/RSA root self-signatures",
        "OpenSSL-generated three-certificate suralang.site test chain"
      ],
      "executed_markers": [
        "SURA_SHA256_OK",
        "SURA_SHA384_OK",
        "SURA_HMAC_SHA256_OK",
        "SURA_HKDF_SHA256_OK",
        "SURA_TLS13_LABEL_OK",
        "SURA_AES128_OK",
        "SURA_AES128_GCM_OK",
        "SURA_X25519_OK",
        "SURA_TLS13_RECORD_OK",
        "SURA_TLS13_KEY_SCHEDULE_OK",
        "SURA_TLS13_HELLO_OK",
        "SURA_ENTROPY_X86_OK",
        "SURA_RSA_PUBLIC_OK",
        "SURA_RSA_SHA256_VERIFY_OK",
        "SURA_DER_READER_OK",
        "SURA_X509_CHAIN_OK",
        "SURA_TLS13_APPLICATION_OK",
        "SURA_TLS13_MESSAGES_OK",
        "SURA_TLS_CRYPTO_OK"
      ],
      "negative_checks": [
        "modified GCM tag rejected",
        "unauthenticated plaintext output remains unchanged",
        "malformed ServerHello length rejected",
        "HelloRetryRequest rejected",
        "all-zero server X25519 share rejected",
        "wrong hostname rejected",
        "expired certificate rejected",
        "untrusted root rejected",
        "invalid calendar date rejected",
        "unknown critical X.509 extension rejected"
      ],
      "trust_anchors": [
        "ISRG Root X1",
        "DigiCert Global Root G2",
        "GlobalSign Root CA - R3",
        "Amazon Root CA 1",
        "USERTrust RSA Certification Authority",
        "Microsoft RSA Root Certificate Authority 2017"
      ],
      "trust_store": [
        "tools/sura_trust_store_generate.ps1 pins DER length and SHA-256 before source replacement",
        "indexed DER, byte-count, and fingerprint accessors",
        "HTTPS initialization loop accepts 1 through 16 generated roots",
        "tools/sura_trust_store_qemu_gate.ps1",
        "post-ExitBootServices digest, X.509 parse, CA/key-usage/time/RSA validation, SHA-256/SHA-384 self-signature verification, and one-byte signature-mutation rejection for every generated root",
        "SURA_TRUST_STORE_OK"
      ],
      "limitations": [
        "the isolated gate is not an Internet-connection proof",
        "implemented HTTPS profile is TLS_AES_128_GCM_SHA256 with X25519, RSA/SHA-256 or RSA/SHA-384 chains, and RSA-PSS-RSAE-SHA256 CertificateVerify",
        "six pinned built-in trust anchors rather than a broad operating-system root store",
        "no revocation checking or session resumption",
        "table-based AES implementation is not claimed to be cache-side-channel hardened"
      ]
    },
    "static_data": [
      "static.zero",
      "static.bytes",
      "static.u8",
      "static.u16",
      "static.u32",
      "static.u64",
      "static.utf8",
      "static.utf16",
      "static.struct"
    ],
    "layout": [
      "typed struct fields",
      "natural alignment",
      "struct Name packed",
      "sizeof",
      "alignof",
      "offset_of",
      "typed pointer field load/store"
    ],
    "low_level": [
      "raw memory 8/16/32/64",
      "port I/O 8/16/32",
      "control registers",
      "MSR",
      "GDT",
      "IDT",
      "INVLPG",
      "CPUID",
      "RDTSC/RDTSCP",
      "RDRAND",
      "XGETBV/XSETBV"
    ],
    "cpu_state": {
      "tss": [
        "RSP0..2",
        "IST1..7",
        "I/O-map offset",
        "checked 16-byte GDT TSS descriptor",
        "LTR/STR"
      ],
      "descriptors": [
        "direct table+size LGDT/LIDT",
        "CS/DS/ES/SS reload"
      ],
      "extended_state": [
        "FNINIT",
        "CLTS",
        "FXSAVE64/FXRSTOR64",
        "XSAVE64/XRSTOR64",
        "SWAPGS",
        "STAC/CLAC",
        "WBINVD"
      ]
    },
    "smp_primitives": {
      "percpu": [
        "IA32_GS_BASE",
        "IA32_KERNEL_GS_BASE",
        "GS-relative 8/16/32/64-bit read/write"
      ],
      "apic": [
        "runtime xAPIC/x2APIC selection",
        "APIC ID",
        "register read/write",
        "EOI",
        "ICR busy",
        "IPI",
        "INIT",
        "SIPI"
      ],
      "compile_time_checks": [
        "APIC register offset alignment/range",
        "constant SIPI address alignment/range",
        "constant destination width"
      ]
    },
    "ap_startup": {
      "library": "stdlib/freestanding/ap_startup.sura",
      "trampoline": [
        "230-byte template",
        "16-bit real mode",
        "PAE and EFER.LME",
        "caller PML4",
        "small GDT",
        "64-bit Sura entry",
        "atomic ready flag"
      ],
      "sequence": [
        "bounded ICR waits",
        "INIT",
        "10 ms TSC delay",
        "SIPI",
        "200 us TSC delay",
        "optional second SIPI",
        "bounded ready wait"
      ],
      "example": "examples/os/ap_startup_features.sura",
      "verification": "tools/sura_ap_startup_smoke.ps1 checks the exact assembled 230-byte template in the generated EFI image",
      "limitations": [
        "caller discovers APs and calibrates TSC",
        "caller supplies a writable virtual alias for the low page",
        "caller identity-maps the trampoline and maps all entry parameters",
        "PML4 physical address must fit in 32 bits",
        "no per-AP descriptor/extended-state/scheduler initialization",
        "no 82489DX INIT-deassert sequence",
        "compile-only verification; no executed AP-start proof"
      ]
    },
    "paging_primitives": {
      "address": [
        "PML4/PDPT/PD/PT index",
        "page offset",
        "48-bit canonical-address test"
      ],
      "entries": [
        "construct",
        "address",
        "flags",
        "present",
        "large",
        "read",
        "write",
        "map",
        "clear"
      ],
      "tlb": [
        "CR3 root",
        "activate root",
        "INVLPG",
        "local CR3 flush"
      ],
      "compile_time_checks": [
        "constant page-table index range",
        "constant physical/root 4-KiB alignment"
      ]
    },
    "memory_libraries": {
      "physical": [
        "UEFI conventional-memory import",
        "bitmap reserve/release",
        "single-page allocation",
        "aligned contiguous allocation",
        "free-page accounting"
      ],
      "virtual": [
        "conflict-checked table linking",
        "4-KiB map/unmap/protect",
        "4-KiB/2-MiB/1-GiB translation",
        "local invalidation"
      ],
      "lifecycle": [
        "memory-map retry",
        "ExitBootServices before direct allocation",
        "no firmware calls or return after successful exit"
      ],
      "example": "examples/os/memory_kernel.sura",
      "limitations": [
        "no internal SMP lock",
        "no NUMA/DMA zones",
        "generic virtual helper requires caller-provided intermediate tables",
        "no remote TLB shootdown"
      ]
    },
    "framebuffer_graphics": {
      "libraries": [
        "stdlib/freestanding/framebuffer.sura",
        "stdlib/freestanding/font5x7.sura",
        "stdlib/freestanding/font_hangul.sura",
        "stdlib/freestanding/font_ui.sura",
        "stdlib/freestanding/font_ui_atlas.sura"
      ],
      "example": "examples/os/framebuffer_features.sura",
      "surface_contract": "caller-owned 32-bit GOP RGB/BGR surface, bounded to 64 MiB",
      "drawing": [
        "checked pixel access",
        "clipped fill and outline rectangles",
        "horizontal and vertical lines",
        "integer Bresenham lines",
        "basic application icon",
        "5x7 fixed-width bitmap text",
        "proportional 16-pixel ASCII and modern-Hangul text with 2-bit antialias blending"
      ],
      "presentation": [
        "caller-owned backbuffer",
        "64-bit full-frame copy presentation",
        "clipped rectangle copy for software-cursor damage repair",
        "sampled framebuffer hash"
      ],
      "executed_resolution": "1280x800 in the current QEMU/EDK2 gate",
      "screenshot_gate": "tools/sura_os_screenshot.ps1 captures the actual QEMU framebuffer through loopback-only QMP after SURA_OS_DESKTOP_OK",
      "limitations": [
        "no hardware acceleration, GPU driver, or accelerated compositing",
        "polling xHCI USB boot keyboard/mouse with PS/2 fallback rather than interrupt-driven physical-hardware input proof",
        "the UI atlas covers printable ASCII and modern precomposed Hangul rather than all Unicode or complex shaping"
      ]
    },
    "graphical_text_terminal": {
      "library": "stdlib/freestanding/text_terminal.sura",
      "model": "caller-owned fixed-capacity Unicode-code-point cell buffer",
      "limits": [
        "1..256 columns",
        "1..128 rows"
      ],
      "operations": [
        "Unicode scalar",
        "checked UTF-8 output",
        "code-point Backspace",
        "newline",
        "wrap",
        "upward scroll",
        "clear",
        "bounded C-string output",
        "unsigned decimal output",
        "16-pixel UI-font framebuffer draw"
      ],
      "os_instance": "46x14 command history rendered with the proportional ASCII/modern-Hangul UI font and shared by COM1 and decoded xHCI-or-PS/2 keyboard input",
      "commands": [
        "help",
        "status",
        "mem",
        "about",
        "clear",
        "shutdown",
        "reboot"
      ],
      "example": "examples/os/text_terminal_features.sura",
      "executed_verification": "QMP keyboard input fills and scrolls the 14-row OS terminal, clears it, enters dkssudgktpdy as 안녕하세요 through the common two-set input path, and leaves a visible status result; serial markers prove scroll, clear, and exact Korean UTF-8 input",
      "limitations": [
        "built-in command names are ASCII",
        "the font atlas covers printable ASCII and modern precomposed Hangul rather than all Unicode",
        "no ANSI escape parser",
        "no selection, clipboard, alternate buffer, or scrollback beyond visible rows"
      ]
    },
    "window_manager_foundation": {
      "library": "stdlib/freestanding/window_manager.sura",
      "model": "caller-owned fixed-capacity window records with no dynamic allocation",
      "limits": [
        "1..64 registered windows",
        "windows must fit inside the desktop area above the taskbar"
      ],
      "operations": [
        "normal, minimized, maximized, and fullscreen state",
        "restore geometry",
        "visible and active state",
        "z-order",
        "focus",
        "top-window hit testing",
        "title-bar drag",
        "bottom-right resize",
        "minimize, maximize, restore, fullscreen, close, and show",
        "desktop-bound clamping"
      ],
      "example": "examples/os/window_manager_features.sura",
      "os_integration": "Six application windows use the manager for focus, z-order, title-bar drag, interactive resize, minimize/taskbar restore, maximize/restore, fullscreen/restore, close/reopen, bounds, Start/taskbar activation, active-window keyboard routing, and FAT32-backed desktop-state restore",
      "verification": "compile and EFI image verification plus QEMU focus, drag, resize, minimize/taskbar restore, maximize/restore, fullscreen/restore, close, Start activation, serial-marker, and screenshot verification",
      "limitations": [
        "the manager stores geometry and state but does not own application rendering",
        "no animation, snap layout, drag-and-drop, or real multi-output presentation"
      ]
    },
    "window_server_and_common_ui": {
      "window_server_library": "stdlib/freestanding/window_server.sura",
      "common_ui_library": "stdlib/freestanding/ui.sura",
      "ring3_worker_source": "os/user_window_server.sura",
      "model": [
        "caller-owned application surfaces",
        "separate compositor output",
        "opaque z-order composition",
        "bounded damage rectangles",
        "failed-owner surface removal",
        "clipboard",
        "light and dark themes",
        "DPI scaling",
        "two-monitor virtual-desktop records"
      ],
      "common_controls": [
        "button",
        "text input",
        "list",
        "menu",
        "checkbox",
        "focus and hit testing",
        "activation",
        "accessible role and name metadata"
      ],
      "shared_buffer_path": "the kernel maps the real GOP backbuffer pages into the dedicated Window Server ProcessAddressSpace through process_space_map_shared_page; the executed boot reads one pixel, writes a test value, verifies it, and restores the original value",
      "example": "examples/os/window_server_features.sura",
      "gate": "tools/sura_window_server_qemu_gate.ps1",
      "executed_markers": [
        "SURA_WINDOW_SERVER_OK",
        "SURA_OS_WINDOW_SERVER_RING3_READY",
        "SURA_OS_WINDOW_SERVER_CR3_OK",
        "SURA_OS_WINDOW_SERVER_SHARED_BUFFER_OK",
        "SURA_OS_WINDOW_SERVER_RING3_OK"
      ],
      "limitations": [
        "the persistent Ring-3 worker executes a bounded 16x16 two-surface composition job, but the six built-in application content renderers still draw in ring 0",
        "full-size per-application Ring-3 surfaces have not been connected to the compositor",
        "no window animations, drag-and-drop service, real multi-output scanout, or complete accessibility service"
      ]
    },
    "desktop_shell": {
      "library": "stdlib/freestanding/desktop_shell.sura",
      "model": "fixed-layout caller-rendered Start menu, taskbar, and desktop-icon hit testing",
      "actions": [
        "Start toggle",
        "Terminal/System/Files/Editor/Calculator menu",
        "shutdown",
        "Terminal/System/Files/Editor/Calculator taskbar",
        "About/Files/Editor/Calculator icon"
      ],
      "state": [
        "screen and taskbar dimensions",
        "Start open",
        "last action"
      ],
      "example": "examples/os/desktop_shell_features.sura",
      "os_integration": "Start and taskbar activation, close/reopen routing, mounted Files window, and desktop shutdown dispatch",
      "limitations": [
        "fixed coordinates and launcher entries",
        "caller performs rendering and window actions",
        "no settings store, notifications, or process launcher"
      ]
    },
    "desktop_applications": {
      "library": "stdlib/freestanding/desktop_apps.sura",
      "ring3_worker_source": "os/user_worker.sura",
      "ring3_system_info_source": "os/user_system_info.sura",
      "ring3_terminal_source": "os/user_terminal.sura",
      "ring3_file_explorer_source": "os/user_file_explorer.sura",
      "ring3_editor_source": "os/user_text_editor.sura",
      "ring3_calculator_source": "os/user_calculator.sura",
      "ring3_window_server_source": "os/user_window_server.sura",
      "ring3_browser_source": "os/user_browser.sura",
      "applications": {
        "system_information": [
          "kernel-gathered bounded framebuffer, free-page, storage, and network snapshot",
          "fixed CPL-3 snapshot validation and derived free-memory MiB/pixel count worker with a bounded mailbox",
          "ring-0 activation and rendering after return"
        ],
        "file_explorer": [
          "bounded entry count and selection",
          "fixed CPL-3 selection worker with a bounded mailbox",
          "executed OS traverses the SuraFS UTF-8 /문서 tree through VFS, opens /문서/메모.txt, creates files and folders, renames UTF-8 names, transfers entries to /휴지통, permanently deletes only from the recycle bin, and performs Ctrl+C/Ctrl+X/Ctrl+V file and bounded complete-directory-tree copy/move after returning to ring 0"
        ],
        "text_editor": [
          "4096-byte caller-owned buffer",
          "UTF-8 byte-boundary cursor and selection anchor",
          "printable and packed UTF-8 insertion at the cursor",
          "selected-range replacement",
          "LF-normalized Enter",
          "UTF-8 code-point Backspace and Delete",
          "dirty state",
          "8288-byte three-page CPL-3 editing mailbox with separate document and insertion payload",
          "selection highlighting",
          "automatic UTF-8 wrapping and cursor-following viewport",
          "Ctrl+A/C/X/V selection clipboard",
          "Shift+Left/Right and Shift+Home/End selection extension",
          "Ctrl+F next-match selection",
          "Ctrl+H bounded replacement through the CPL-3 editor worker",
          "lower-case .sura path association with bounded lexical colors for keywords, quoted strings, # line comments, and numbers",
          "non-destructive 62-byte /문서/main.sura starter creation",
          "executed OS atomically replaces and autosaves the selected SuraFS file",
          "Ctrl+S forced save",
          "Ctrl+Shift+S UTF-8 Save As without silent overwrite"
        ],
        "calculator": [
          "unsigned integer input",
          "+",
          "-",
          "*",
          "/",
          "=",
          "C",
          "Backspace",
          "full expression and result display",
          "clickable 4x4 keypad plus keyboard input",
          "overflow, underflow, and division-by-zero error state",
          "fixed CPL-3 state worker with a bounded mailbox"
        ]
      },
      "example": "examples/os/desktop_apps_features.sura",
      "os_integration": "registered windows 2..6, desktop/Start/taskbar launch and reopen, and active-app input routing; System Information, Terminal, File Explorer, Text Editor, Calculator, Window Server, and Browser request validator are seven persistent UserProcessScheduler processes with separate CR3 roots, event queues, and kernel stacks. The Window Server has a mapped real backbuffer and executes a bounded compositor job. The Browser worker validates a private copied URL snapshot and returns scheme/host/path plus network/storage/device capabilities before a request, while network, TLS, DOM, layout, and rendering remain in ring 0",
      "executed_verification": "QEMU initializes the seven-process graphical scheduler, validates a System Information snapshot through its persistent CPL-3 path before ring-0 rendering, edits and recognizes Terminal commands through the Terminal CPL-3 path before ring-0 rendering and privileged execution, mounts SuraFS through VFS, selects /문서 and opens /문서/메모.txt through the File Explorer CPL-3 path before ring-0 traversal, creates and renames ASCII and Korean entries, transfers a folder to /휴지통, copies an exact 43-byte UTF-8 file, moves it into movebox, recursively duplicates that complete folder tree, appends ASCII, LF, and Korean UTF-8 through the Text Editor CPL-3 mailbox, completes Ctrl+F and bounded Ctrl+H replacement, selects and copies the complete document, cuts it through CPL-3 range deletion, pastes it through the bounded CPL-3 payload, saves an exact /문서/copy.sura duplicate through Save As, activates bounded .sura syntax coloring, flushes through AHCI after returning to ring 0, restores the exact payload and full mutation tree on a preserved second boot, evaluates keyboard 50 - 31 = 19 and graphical-keypad 7 + 5 = 12 through the Calculator CPL-3 path, verifies seven distinct worker CR3 roots and stable saved frames/kernel stacks after repeated GUI requests, deliberately faults the blocked Calculator through faultapp, requires SURA_OS_USER_PROCESS_FAULT and SURA_OS_USER_PROCESS_ISOLATED, reaps and recreates it with a new process ID and CR3, requires SURA_OS_USER_PROCESS_RESTARTED, executes a real Calculator event and requires SURA_OS_USER_PROCESS_RESTART_EVENT_OK, then requires the persistent Terminal status command to print kernel: ready; it next sends hangapp, queues a System Information request, waits for SURA_OS_USER_PROCESS_HANG_STARTED, injects mouse movement during the non-yielding Calculator loop, requires SURA_OS_USER_PROCESS_WATCHDOG, SURA_OS_USER_PROCESS_HANG_INPUT_OK, and SURA_OS_USER_PROCESSES_CONCURRENT_OK, verifies that System Information completed under its own CR3 through SURA_OS_USER_PROCESS_BACKGROUND_OK, isolates and reconstructs Calculator again, executes a real event, requires SURA_OS_USER_PROCESS_HANG_RECOVERED, and finally requires another persistent Terminal status response before shutdown; it also executes the persistent Window Server worker, checks exact bounded two-surface composition, maps the real GOP backbuffer into that worker, verifies one pixel write, and restores the original pixel; the Browser request worker validates copied request metadata and capabilities under its distinct CR3, and faultbrowser verifies isolated reconstruction plus a real post-restart authorization",
      "limitations": [
        "built-in application content rendering remains kernel-owned; the Ring-3 Window Server currently proves bounded composition and real-backbuffer access rather than presenting full-size app-owned surfaces",
        "the scheduler accepts events for multiple workers and executes a real System Information job while Calculator is non-yielding, but ordinary UI handlers still wait for their own result; a user-facing background-job API is not implemented",
        "automatic recovery reconstructs the failed worker from its built-in app image; it does not restore an arbitrary instruction-level process checkpoint",
        "hardware snapshot gathering, terminal rendering and privileged commands, VFS/SuraFS traversal, mutation, and Text Editor persistence remain ring-0 operations after their workers return",
        "File Explorer enumerates at most the 32-node formatted capacity in a six-row scrolling viewport and has no search, sorting, properties dialog, progress UI, or interactive overwrite-conflict dialog; paste resolves conflicts with bounded Copy suffixes",
        "Text Editor has keyboard selection, clipboard editing, bounded find/replace, and lexical .sura colors but no mouse selection, vertical line-aware cursor movement, multi-document editing, parser diagnostics, completion, or semantic highlighting",
        "Calculator is unsigned integer only"
      ]
    },
    "cmos_rtc": {
      "library": "stdlib/freestanding/rtc.sura",
      "operations": [
        "bounded update-window wait",
        "two matching samples",
        "BCD conversion",
        "12-hour to 24-hour conversion",
        "hour/minute/second validation"
      ],
      "example": "examples/os/rtc_features.sura",
      "os_integration": "HH:MM taskbar clock refreshed on sampled second changes with SURA_OS_RTC_OK after a valid QEMU RTC read",
      "limitations": [
        "PC CMOS ports 0x70/0x71 only",
        "time only; no date, timezone, monotonic clock, or alarm"
      ]
    },
    "ps2_desktop_input": {
      "library": "stdlib/freestanding/ps2.sura",
      "controller": [
        "bounded i8042 waits",
        "translated Set-1 keyboard enable",
        "standard auxiliary mouse enable",
        "polling data-source dispatch"
      ],
      "keyboard": [
        "physical Set-1 position",
        "press/release/repeat",
        "left/right Shift, Ctrl, and Alt",
        "Caps Lock",
        "Korean Hangul/Hanja make keys",
        "printable Unicode scalar",
        "Enter",
        "Backspace",
        "extended-key tracking"
      ],
      "desktop_queue": [
        "64-entry kernel-owned IpcQueue",
        "KeyEvent encode/decode round trip",
        "press and release delivery",
        "active-window routing after dequeue",
        "SURA_OS_INPUT_EVENT_OK"
      ],
      "mouse": [
        "three-byte relative packets",
        "signed movement",
        "screen bounds",
        "three button transitions"
      ],
      "example": "examples/os/ps2_features.sura",
      "executed_verification": "tools/sura_os_screenshot.ps1 exercises Shift, Backspace, status, Korean mode and exact dkssudgktpdy to 안녕하세요 input, pointer movement, focus, title-bar drag, close, taskbar reopen, and Start-menu activation through QEMU QMP",
      "limitations": [
        "kernel polling queue rather than IRQ1/IRQ12 device delivery",
        "no scheduled-process input delivery",
        "only English-US and Korean two-set layouts",
        "the PS/2 fallback negotiates IntelliMouse wheel packets but has no five-button support",
        "the desktop prefers xHCI when both USB devices enumerate"
      ]
    },
    "unicode_text_input": {
      "libraries": [
        "stdlib/freestanding/key_event.sura",
        "stdlib/freestanding/text_input.sura",
        "stdlib/freestanding/font_hangul.sura",
        "stdlib/freestanding/font_ui.sura",
        "stdlib/freestanding/font_ui_atlas.sura"
      ],
      "model": "device-independent physical KeyEvent and Unicode scalar composition with caller-owned editor storage",
      "key_event": [
        "physical key",
        "raw scan code",
        "Unicode scalar",
        "press/release/repeat",
        "Shift/Ctrl/Alt/Caps/Hangul modifiers",
        "monotonic sequence"
      ],
      "hangul": [
        "English/Hangul mode",
        "modern two-set Korean mapping",
        "initial/medial/final composition",
        "compound vowels and finals",
        "final split before following vowel",
        "composition-aware Backspace"
      ],
      "output": [
        "up to two committed Unicode scalars per key",
        "current composition preview",
        "checked UTF-8 encoding for one through four bytes"
      ],
      "desktop_integration": [
        "Text Editor and Terminal CPL-3 packed UTF-8 mailboxes",
        "UTF-8 code-point Backspace",
        "distinct lowercase ASCII",
        "proportional 16-pixel 2-bit-antialiased ASCII and modern-Hangul framebuffer atlas",
        "live composition preview",
        "global Right Alt and dedicated Hangul-key mode switching",
        "clickable System Information keyboard setting",
        "SETTINGS.CFG mode persistence",
        "Text Browser UTF-8 address-bar and page-body paths",
        "HTTP uppercase percent encoding"
      ],
      "example": "examples/os/text_input_features.sura",
      "executed_gate": "tools/sura_text_input_qemu_gate.ps1 with SURA_KEY_EVENT_OK, SURA_TEXT_INPUT_ANNYEONGHASEYO_OK, and SURA_TEXT_INPUT_OK",
      "executed_scope": [
        "Set-1 press/release/repeat",
        "Shift/Ctrl/Alt/Caps",
        "Caps-independent Korean physical mapping",
        "exact dkssudgktpdy to 안녕하세요 physical-key composition",
        "compound vowel",
        "final deletion",
        "exact UTF-8 bytes"
      ],
      "desktop_gate": "tools/sura_os_screenshot.ps1 with SURA_OS_INPUT_EVENT_OK, SURA_OS_INPUT_LAYOUT_OK, SURA_OS_KOREAN_INPUT_OK, SURA_OS_TERMINAL_KOREAN_INPUT_OK, SURA_OS_BROWSER_KOREAN_INPUT_OK, SURA_OS_BROWSER_LINK_OK, SURA_OS_BROWSER_WHEEL_OK, SURA_OS_BROWSER_SCROLL_OK, SURA_OS_KEY_REPEAT_OK, SURA_OS_BROWSER_BACKSPACE_REPEAT_OK, SURA_OS_BROWSER_NAV_ASYNC_BEGIN, SURA_OS_BROWSER_NAV_ASYNC_INPUT_OK, SURA_OS_BROWSER_NAV_ASYNC_DONE, SURA_OS_BROWSER_NAV_TLS_BEGIN, SURA_OS_BROWSER_NAV_TLS_DONE, SURA_OS_BROWSER_NAV_FETCH_CANCEL_REQUESTED, SURA_OS_BROWSER_NAV_FETCH_CANCELLED_OK, build/os/SuraOS-korean-input.ppm, build/os/SuraOS-browser.ppm, build/os/SuraOS-browser-scrolled.ppm, and build/os/SuraOS-browser-korean.ppm; the gate starts a real DNS query for a reserved invalid TLD, processes F6 while it is pending, cancels the stale URL snapshot, and then completes the separate explicit-http example.org live non-default-host response check; it also advances two live suralang.site TLS handshakes incrementally, cancels one later response fetch with F6, retries it, and then executes certificate validation, encrypted response, external CSS, DOM layout, anchor hit-testing, wheel scrolling, held Page Down, and held UTF-8 Backspace; tools/sura_input_layout_qemu_gate.ps1 preserves the data disk and requires SURA_OS_INPUT_LAYOUT_RESTORED on a second boot",
      "limitations": [
        "modern Korean composition and precomposed-Hangul atlas only",
        "DNS host names need ASCII because IDNA is absent",
        "Terminal commands remain ASCII",
        "no Hanja conversion, candidate UI, full Unicode font, complex shaping, or normalization"
      ]
    },
    "context_primitives": {
      "frame_bytes": 72,
      "saved_registers": [
        "r15",
        "r14",
        "r13",
        "r12",
        "rsi",
        "rdi",
        "rbp",
        "rbx",
        "resume RIP"
      ],
      "operations": [
        "initialize aligned task frame",
        "save current RSP",
        "resume next RSP",
        "entry(argument)",
        "exit_handler(result)"
      ],
      "limitations": [
        "no RFLAGS",
        "no FPU/SIMD",
        "no CR3",
        "no FS/GS base",
        "integer cooperative context only"
      ]
    },
    "scheduler_library": {
      "model": "single-CPU cooperative round-robin",
      "operations": [
        "init",
        "create",
        "yield",
        "tick",
        "sleep",
        "block",
        "wake",
        "join",
        "reap"
      ],
      "states": [
        "unused",
        "runnable",
        "finished",
        "sleeping",
        "blocked"
      ],
      "example": "examples/os/scheduler_features.sura",
      "limitations": [
        "no interrupt-frame preemption",
        "no SMP run-queue synchronization",
        "no FPU/SIMD context save",
        "caller supplies task storage and stacks"
      ]
    },
    "preemptive_scheduler_and_timer": {
      "model": "single-CPU ring-0 round-robin from checked interrupt frames",
      "frame": [
        "152-byte integer/error/RIP/CS/RFLAGS frame",
        "checked canonical addresses",
        "ring-0 CS",
        "CLI before IRETQ resume"
      ],
      "scheduler": [
        "create",
        "timer selection",
        "vector-129 voluntary yield",
        "sleep",
        "block",
        "wake",
        "join",
        "exit",
        "reap"
      ],
      "timer": [
        "local-APIC periodic/one-shot count",
        "bounded PIT channel-2 calibration",
        "TSC-deadline mode"
      ],
      "libraries": [
        "stdlib/freestanding/preempt.sura",
        "stdlib/freestanding/timer.sura"
      ],
      "example": "examples/os/preemptive_timer_features.sura",
      "limitations": [
        "compile and machine-code verification only",
        "ring-0 tasks only",
        "no FPU/SIMD, CR3, FS/GS, debug, or process state",
        "no priorities",
        "no SMP locking or load balancing",
        "caller installs IDT and programs per-CPU timer"
      ]
    },
    "software_interrupt_syscalls": {
      "invoke": "syscall.invoke(vector, number, argument...)",
      "argument_registers": [
        "RAX number",
        "RDI",
        "RSI",
        "RDX",
        "R10",
        "R8"
      ],
      "dispatcher": "stdlib/freestanding/syscall.sura",
      "example": "examples/os/syscall_features.sura",
      "limitations": [
        "dispatcher does not automatically validate user pointers",
        "caller selects the current process and applies checked copy helpers",
        "caller owns CPL/DPL, permissions, locking, and fault policy"
      ]
    },
    "fast_syscalls_and_user_mode": {
      "invoke": "syscall.fast(number, argument...)",
      "configure": "syscall.fast_configure(dispatch, bad_return, kernel_cs, user_cs, flags_mask, kernel_rsp_offset, user_rsp_offset)",
      "entry": "user.enter(entry, stack_pointer, argument, code_selector, stack_selector)",
      "saved_frame": [
        "user.frame_size()",
        "user.frame_init(kernel_stack_top, entry, user_rsp, argument, code_selector, stack_selector)",
        "user.frame_valid(frame)",
        "user.resume(frame)"
      ],
      "address_check": "user.is_address(address)",
      "argument_registers": [
        "RAX number",
        "RDI",
        "RSI",
        "RDX",
        "R10",
        "R8"
      ],
      "entry_contract": [
        "EFER.SCE and STAR/LSTAR/FMASK configuration",
        "conditional saved-CS SWAPGS and LFENCE in compiler interrupt wrappers",
        "GS-relative user-RSP save and kernel-RSP load",
        "15-register integer fast frame",
        "168-byte user IRET frame",
        "validated lower-half canonical RIP/RSP",
        "ring-3 CS/SS and sanitized user RFLAGS",
        "SYSRETQ/IRETQ"
      ],
      "example": "examples/os/user_mode_features.sura",
      "executed_gate": "tools/sura_ring3_qemu_gate.ps1",
      "executed_source": "examples/os/ring3_qemu_gate.sura",
      "executed_markers": [
        "SURA_RING3_READY",
        "SURA_RING3_4K_PAGES or SURA_RING3_SPLIT_LARGE_PAGE",
        "SURA_RING3_CPL3_SYSCALL_OK"
      ],
      "executed_path": [
        "ExitBootServices",
        "GDT/TSS/IDT activation",
        "4-KiB user code and NX stack permissions",
        "IRETQ entry with CS 35",
        "DPL-3 INT 0x80 with saved-CS check",
        "IRETQ return to CPL 3",
        "SYSCALL kernel-stack entry",
        "ring-0 debug exit"
      ],
      "desktop_process_gate": [
        "System Information, Terminal, File Explorer, Text Editor, and Calculator use distinct ProcessAddressSpace CR3 roots",
        "shared kernel PML4 entries have U/S cleared",
        "process-owned W^X code",
        "writable/NX mailboxes",
        "guarded writable/NX user stacks",
        "SURA_OS_SYSTEM_CR3_OK, SURA_OS_TERMINAL_CR3_OK, SURA_OS_FILES_CR3_OK, SURA_OS_EDITOR_CR3_OK, and SURA_OS_CALCULATOR_CR3_OK after the interrupt handler observes each process root and restores the kernel root"
      ],
      "limitations": [
        "entry primitive does not automatically select an address space or validate syscall pointers",
        "standalone executed gate is one fixed test context, not a scheduled desktop application process",
        "the graphical desktop uses UserProcessScheduler rather than the standalone user.enter primitive and does not load those workers from ELF files",
        "generic interrupt wrapper is not an NMI/MCE paranoid-entry implementation",
        "no KPTI or comprehensive speculative-entry hardening",
        "no FPU/SIMD save"
      ]
    },
    "process_address_space_and_elf64": {
      "address_space": [
        "new lower-half user PML4",
        "supervisor-only shared upper-half kernel entries",
        "automatic 4-KiB intermediate-table allocation",
        "empty-table reclamation",
        "fixed-capacity ownership and mapping records",
        "guarded writable NX stacks"
      ],
      "security_checks": [
        "nonzero lower-half canonical ranges",
        "non-present nonzero conflict rejection",
        "U/S page permissions",
        "W^X leaves",
        "complete-range copy preflight",
        "PTE-to-owned-physical-page agreement",
        "active-CR3 destruction rejection"
      ],
      "user_copy": [
        "process_copy_to_user",
        "process_copy_from_user"
      ],
      "elf_scope": "little-endian System V/Linux x86-64 static ET_EXEC",
      "elf_checks": [
        "ELF identity and fixed header sizes",
        "bounded complete program-header table",
        "file and memory overflow bounds",
        "sorted readable PT_LOAD segments",
        "power-of-two alignment and page-offset congruence",
        "no page-overlapping loads",
        "no W+X",
        "entry inside executable load segment",
        "non-executable GNU stack"
      ],
      "elf_load": [
        "zeroed pages",
        "file-byte copy",
        "p_memsz tail zero-fill",
        "final per-segment W^X permissions",
        "mapping rollback on failure"
      ],
      "libraries": [
        "stdlib/freestanding/process_memory.sura",
        "stdlib/freestanding/elf64.sura"
      ],
      "example": "examples/os/process_elf_features.sura",
      "limitations": [
        "no ET_DYN, ASLR, relocation, interpreter, dynamic linking, or TLS",
        "no demand paging, copy-on-write, shared memory, or memory-mapped files",
        "no signal policy",
        "no PCID, KPTI, or remote TLB shootdown",
        "caller serializes mappings and provides identity-accessible physical pages",
        "compile and image verification only; self-check not executed in the current gate"
      ]
    },
    "user_process_lifecycle": {
      "model": "fixed-capacity single-CPU ring-3 round-robin with a ring-0 idle frame",
      "frame": [
        "168-byte normalized GP/error/RIP/CS/RFLAGS/RSP/SS layout",
        "checked lower-half RIP/RSP",
        "RPL-3 CS/SS",
        "IOPL/NT/VM rejection",
        "CLI, SWAPGS, LFENCE, IRETQ resume"
      ],
      "switching": [
        "per-process CR3",
        "per-process TSS RSP0",
        "per-process user GS base",
        "timer preemption",
        "DPL-3 vector-130 voluntary yield",
        "timer return to a saved Ring-0 service frame",
        "last-user cursor for round-robin order across kernel slices"
      ],
      "lifecycle": [
        "checked creation from ProcessAddressSpace",
        "optional per-process kernel event queue",
        "blocked state with saved IRET frame",
        "atomic wake-on-event post",
        "block/wake counters",
        "kernel-slice counter",
        "authenticated kernel-side event delivery and receive",
        "non-returning self-exit",
        "kernel termination of a non-current runnable or blocked process",
        "ring-3 page-fault termination with CR2/error capture",
        "state/result/fault lookup",
        "address-space destruction on reap"
      ],
      "library": "stdlib/freestanding/user_process.sura",
      "example": "examples/os/user_process_features.sura",
      "executed_gate": "tools/sura_user_process_qemu_gate.ps1",
      "executed_markers": [
        "SURA_USER_PROCESS_PREEMPT_OK",
        "SURA_USER_PROCESS_IPC_OK",
        "SURA_USER_PROCESS_FAULT_ISOLATED",
        "SURA_USER_PROCESS_CR3_ISOLATED"
      ],
      "executed_scope": [
        "two runnable CPL-3 processes",
        "periodic local-APIC preemption of a non-yielding loop",
        "distinct process CR3 roots",
        "authenticated IPC delivery",
        "ring-3 page-fault termination",
        "continued kernel and peer-process execution"
      ],
      "kernel_slice_gate": "tools/sura_user_process_kernel_slice_qemu_gate.ps1",
      "kernel_slice_source": "examples/os/user_process_kernel_slice_qemu_gate.sura",
      "kernel_slice_markers": [
        "SURA_USER_PROCESS_KERNEL_SLICE_OK",
        "SURA_USER_PROCESS_INPUT_PROGRESS_OK",
        "SURA_USER_PROCESS_RESUME_OK",
        "SURA_USER_PROCESS_TERMINATE_OK"
      ],
      "kernel_slice_scope": [
        "one non-yielding CPL-3 infinite loop",
        "periodic APIC timer",
        "two returns to the saved Ring-0 input continuation",
        "process frame preservation",
        "kernel CR3 restoration",
        "reschedule and second user execution slice",
        "kernel termination with exit code 137",
        "address-space reap after termination"
      ],
      "persistent_calculator_gate": "tools/sura_persistent_calculator_qemu_gate.ps1",
      "persistent_calculator_source": "examples/os/persistent_calculator_qemu_gate.sura",
      "persistent_calculator_worker": "os/user_calculator.sura",
      "persistent_calculator_markers": [
        "SURA_PERSISTENT_CALCULATOR_READY",
        "SURA_PERSISTENT_CALCULATOR_EVENTS_OK",
        "SURA_PERSISTENT_CALCULATOR_RESULT_OK",
        "SURA_PERSISTENT_CALCULATOR_SAME_PROCESS_OK",
        "SURA_PERSISTENT_CALCULATOR_CR3_OK"
      ],
      "persistent_calculator_scope": [
        "actual copied Sura OS calculator worker",
        "argument-bit opt-in preserving legacy one-shot mode",
        "initial empty-queue block",
        "four kernel wake events",
        "syscall receive into a separate event page",
        "2 + 3 = 5 state transitions",
        "same process ID, CR3, user frame, and kernel stack across five slices"
      ],
      "persistent_desktop_apps_gate": "tools/sura_persistent_desktop_apps_qemu_gate.ps1",
      "persistent_desktop_apps_source": "examples/os/persistent_desktop_apps_qemu_gate.sura",
      "persistent_desktop_workers": [
        "os/user_calculator.sura",
        "os/user_text_editor.sura",
        "os/user_file_explorer.sura",
        "os/user_terminal.sura",
        "os/user_system_info.sura",
        "os/user_window_server.sura"
      ],
      "persistent_desktop_apps_markers": [
        "SURA_PERSISTENT_DESKTOP_APPS_READY",
        "SURA_PERSISTENT_DESKTOP_CALCULATOR_OK",
        "SURA_PERSISTENT_DESKTOP_EDITOR_OK",
        "SURA_PERSISTENT_DESKTOP_FILES_OK",
        "SURA_PERSISTENT_DESKTOP_TERMINAL_OK",
        "SURA_PERSISTENT_DESKTOP_SYSTEM_OK",
        "SURA_PERSISTENT_DESKTOP_WINDOW_SERVER_OK",
        "SURA_PERSISTENT_DESKTOP_SAME_PROCESS_OK",
        "SURA_PERSISTENT_DESKTOP_CR3_OK"
      ],
      "persistent_desktop_apps_scope": [
        "six actual copied Sura OS workers",
        "six independent ProcessAddressSpace roots",
        "six event queues and kernel stacks",
        "one shared UserProcessScheduler",
        "initial block of every process",
        "one kernel wake and real mailbox transition per worker",
        "exact bounded Window Server surface composition",
        "return to blocked state without recreation",
        "distinct CR3 roots and stable process identities"
      ],
      "graphical_desktop_integration": [
        "seven workers created once by the graphical boot path",
        "seven independent event queues and kernel stacks",
        "dedicated Window Server ProcessAddressSpace with mapped GOP backbuffer pages",
        "bounded Ring-3 compositor read, write, verification, and original-pixel restoration",
        "dedicated Browser ProcessAddressSpace with a private 384-byte mailbox containing a copied URL snapshot and explicit network/storage/device capabilities",
        "blocking syscall wait and checked receive",
        "kernel event wake per desktop request",
        "APIC timer return to the Ring-0 service continuation",
        "page-fault handler terminates only the current Ring-3 process",
        "64-slice watchdog termination of a non-yielding graphical worker",
        "mouse polling while the non-yielding worker is interrupted",
        "faulted, exited, or timed-out worker disabled and its window closed without ending the kernel shell",
        "failed address-space reap plus worker/event-queue reconstruction",
        "replacement process with a new ID and CR3 primed back into blocked event wait",
        "previously visible app window reopened after recovery",
        "same saved frame, CR3 root, and kernel stack checked after repeated requests"
      ],
      "graphical_desktop_markers": [
        "SURA_OS_USER_SCHEDULER_READY",
        "SURA_OS_USER_PROCESSES_PERSISTENT_OK",
        "SURA_OS_WINDOW_SERVER_RING3_READY",
        "SURA_OS_WINDOW_SERVER_CR3_OK",
        "SURA_OS_WINDOW_SERVER_SHARED_BUFFER_OK",
        "SURA_OS_WINDOW_SERVER_RING3_OK",
        "SURA_OS_BROWSER_RING3_READY",
        "SURA_OS_BROWSER_RING3_OK",
        "SURA_OS_BROWSER_CR3_OK",
        "SURA_OS_BROWSER_PROCESS_ISOLATED_OK",
        "SURA_OS_USER_PROCESS_FAULT",
        "SURA_OS_USER_PROCESS_ISOLATED",
        "SURA_OS_USER_PROCESS_RESTARTED",
        "SURA_OS_USER_PROCESS_RESTART_EVENT_OK",
        "SURA_OS_USER_PROCESS_HANG_STARTED",
        "SURA_OS_USER_PROCESS_WATCHDOG",
        "SURA_OS_USER_PROCESS_HANG_INPUT_OK",
        "SURA_OS_USER_PROCESSES_CONCURRENT_OK",
        "SURA_OS_USER_PROCESS_BACKGROUND_OK",
        "SURA_OS_USER_PROCESS_HANG_RECOVERED"
      ],
      "worker_event_mapping": [
        "optional page-aligned OsUserWorkerConfig.event_address",
        "writable NX mapping",
        "separate from bounded mailbox",
        "checked complete-page user access"
      ],
      "limitations": [
        "standard GDT selectors 8/27/35",
        "shared supervisor-only kernel code/data/TSS/stacks required",
        "no preemption while a runnable process executes trusted ring-0 code",
        "no fast-syscall blocking/resume conversion",
        "no FPU/SIMD or debug-state save",
        "no signals, priorities, SMP queues, PCID, KPTI, remote TLB shootdown, or NMI-safe entry",
        "ordinary graphical request handlers wait until their requested worker blocks again or reaches the bounded 64-slice service limit, although other already-queued workers advance during those slices",
        "recovery starts a fresh built-in worker and does not checkpoint arbitrary user-process memory or execution state"
      ]
    },
    "ipc_event_queues": {
      "model": "fixed-capacity caller-owned non-blocking FIFO queues with kernel-authenticated endpoints",
      "message": [
        "sequence",
        "kind",
        "source process",
        "target process",
        "flags",
        "four u64 values"
      ],
      "behavior": [
        "FIFO push/peek/pop",
        "monotonic nonzero sequence",
        "full-queue rejection",
        "saturating dropped counter",
        "endpoint sender/target overwrite",
        "receiver ownership check"
      ],
      "library": "stdlib/freestanding/ipc.sura",
      "example": "examples/os/ipc_features.sura",
      "executed_gate": "tools/sura_ipc_qemu_gate.ps1 with SURA_IPC_QUEUE_OK",
      "limitations": [
        "kernel must serialize operations on SMP",
        "non-blocking only",
        "caller owns queue storage"
      ]
    },
    "process_syscall_boundary": {
      "numbers": {
        "getpid": 0,
        "send": 1,
        "receive": 2,
        "yield": 3,
        "exit": 4,
        "wait": 5
      },
      "user_copy": [
        "send copies IpcMessage through process_copy_from_user",
        "receive preflights writable range, peeks, copies through process_copy_to_user, then consumes"
      ],
      "security": [
        "current scheduler process authenticates sender",
        "kernel overwrites source and target",
        "target must be runnable or event-blocked with a queue",
        "invalid output pointers do not consume events",
        "empty-queue check and block are serialized with post-and-wake on the current single CPU"
      ],
      "entry_policy": [
        "getpid/send/receive are table and fast-SYSCALL compatible",
        "yield/exit/wait require process_software_syscall_dispatch and its saved IRET frame"
      ],
      "library": "stdlib/freestanding/process_syscall.sura",
      "example": "examples/os/process_syscall_features.sura",
      "executed_gate": "tools/sura_process_syscall_qemu_gate.ps1 with SURA_PROCESS_SYSCALL_OK",
      "executed_scope": [
        "checked ProcessAddressSpace",
        "getpid",
        "forged-identity replacement",
        "process-to-process send",
        "safe receive copy-out",
        "empty queue",
        "invalid user address"
      ],
      "blocking_wait_gate": "tools/sura_process_wait_qemu_gate.ps1",
      "blocking_wait_source": "examples/os/process_wait_qemu_gate.sura",
      "blocking_wait_markers": [
        "SURA_PROCESS_WAIT_BLOCK_OK",
        "SURA_PROCESS_WAIT_WAKE_OK",
        "SURA_PROCESS_WAIT_RECEIVE_OK",
        "SURA_PROCESS_WAIT_EXIT_OK",
        "SURA_PROCESS_WAIT_CR3_OK"
      ],
      "blocking_wait_scope": [
        "two CPL-3 processes with distinct CR3 roots",
        "empty-queue wait transitions to blocked",
        "send authenticates and wakes target",
        "saved IRET frame resumes after wait",
        "receive copies into the target user address space",
        "both exit paths return to the saved Ring-0 frame"
      ],
      "limitations": [
        "receive itself remains non-blocking; user code calls wait then receive",
        "single shared scratch message and single-CPU serialization",
        "yield is not entered by the process syscall firmware gate",
        "no fast-SYSCALL blocking, yield, or exit resume conversion"
      ]
    },
    "pci_configuration_library": {
      "mechanism": "legacy PCI configuration mechanism 1 through 0xCF8/0xCFC",
      "operations": [
        "BDF validation",
        "8/16/32-bit config access",
        "probe",
        "vendor/device search",
        "class search",
        "capability traversal",
        "BAR decode",
        "command flags"
      ],
      "example": "examples/os/pci_features.sura",
      "limitations": [
        "caller serializes shared config ports",
        "no BAR sizing/resource allocation",
        "no MSI/MSI-X setup",
        "no device-specific driver"
      ]
    },
    "pcie_configuration_library": {
      "discovery": "checksum-validated ACPI MCFG with complete caller-owned region storage",
      "validation": [
        "reserved fields",
        "1-MiB base alignment",
        "segment and bus bounds",
        "physical and same-segment bus overlap rejection",
        "address overflow checks"
      ],
      "operations": [
        "segment-aware 4-KiB ECAM access",
        "8/16/32-bit reads and writes",
        "class enumeration",
        "standard capability traversal",
        "extended capability traversal",
        "BAR decode",
        "command flags"
      ],
      "library": "stdlib/freestanding/pcie.sura",
      "example": "examples/os/pcie_features.sura",
      "limitations": [
        "caller maps ECAM uncached and serializes writes",
        "no executed configuration-space MMIO proof",
        "no BAR sizing or allocation",
        "no bridge setup",
        "no MSI/MSI-X, SR-IOV, ACS/IOMMU policy, or hot-plug"
      ]
    },
    "block_device_library": {
      "contract": "fixed-width synchronous logical-block callbacks with checked geometry, LBA range, transfer overflow, and buffer alignment",
      "operations": [
        "read",
        "write",
        "flush"
      ],
      "adapters": [
        "caller-owned RAM disk",
        "boot-stage UEFI Block I/O"
      ],
      "uefi_checks": [
        "native structure size and offsets",
        "snapshotted media ID and block size",
        "media-change rejection",
        "read-only state"
      ],
      "library": "stdlib/freestanding/block.sura",
      "example": "examples/os/block_features.sura",
      "limitations": [
        "caller owns storage, contexts, buffers, and serialization",
        "bool public result does not preserve detailed callback status",
        "first matching UEFI protocol only",
        "UEFI adapter invalid after ExitBootServices",
        "the current OS executes the generic block ABI through AHCI; RAM and UEFI adapters remain feature-image verified"
      ]
    },
    "ahci_library": {
      "model": "polling AHCI 1.x SATA with one command slot and one PRDT entry",
      "operations": [
        "PCI class discovery and ABAR extraction",
        "BIOS/OS ownership handoff",
        "HBA reset",
        "active SATA port discovery",
        "command engine stop/start",
        "ATA IDENTIFY",
        "48-bit DMA read/write",
        "cache flush",
        "BlockDevice binding"
      ],
      "dma_contract": [
        "caller-owned stable virtual and physical addresses",
        "registered contiguous DMA window",
        "uncached ABAR mapping",
        "non-DMA caller buffers staged through the DMA window in bounded sector-aligned chunks",
        "32-bit controller address-range enforcement"
      ],
      "library": "stdlib/freestanding/ahci.sura",
      "example": "examples/os/ahci_features.sura",
      "executed_verification": "The QEMU q35 OS path discovers ICH9 AHCI, identifies the second SATA disk, DMA-reads its MBR and FAT32 sectors, DMA-writes NOTES/SETTINGS/DESKTOP records, flushes, and remounts the modified image on a second boot",
      "limitations": [
        "polling only; no interrupts or NCQ",
        "one outstanding command",
        "one PRDT entry and one registered DMA scratch window",
        "no ATAPI or port multiplier",
        "no hot-plug, TRIM, COMRESET recovery, or power management",
        "no IOMMU mapping"
      ]
    },
    "nvme_library": {
      "model": "polling NVMe NVM command set with admin queue and I/O queue pair 1",
      "operations": [
        "PCI class discovery and BAR extraction",
        "controller enable/disable",
        "controller and namespace Identify",
        "I/O completion phase tracking",
        "create I/O completion/submission queues",
        "read",
        "write",
        "flush",
        "BlockDevice binding"
      ],
      "dma_contract": [
        "caller-owned contiguous page-aligned queues",
        "registered page-aligned data window",
        "PRP1 plus one direct PRP2 page",
        "arbitrary caller buffers staged through the DMA window in bounded chunks",
        "4-KiB controller minimum page",
        "queue depth at most 64"
      ],
      "library": "stdlib/freestanding/nvme.sura",
      "examples": [
        "examples/os/nvme_features.sura",
        "examples/os/nvme_qemu_gate.sura"
      ],
      "executed_verification": "The direct QEMU gate initializes admin and I/O queues, identifies the controller and namespace, validates a known sector, writes and flushes 8192 bytes through PRP1/PRP2, verifies device readback, and checks the same bytes in the host image. The complete OS selects NVMe before AHCI and mounts its FAT32 settings plus SuraFS document partition through the NVMe BlockDevice.",
      "verification": [
        "tools/sura_nvme_qemu_gate.ps1",
        "tools/sura_os_nvme_qemu_gate.ps1",
        "SURA_NVME_EXECUTED_OK",
        "SURA_OS_STORAGE_NVME_READY"
      ],
      "limitations": [
        "QEMU-only; no physical-hardware proof",
        "no MSI/MSI-X or multiple I/O queue pairs",
        "no concurrent commands",
        "no PRP lists or SGLs",
        "no namespace-list selection",
        "no controller shutdown or abort/reset recovery",
        "no asynchronous events, IOMMU mapping, or zoned namespaces",
        "rejects separate LBA metadata"
      ]
    },
    "xhci_library": {
      "model": "polling xHCI controller with simultaneous directly attached boot-keyboard and boot-mouse interrupt-IN endpoints",
      "operations": [
        "PCI class discovery and MMIO BAR extraction",
        "PCI memory and bus-master enablement",
        "capability parsing",
        "legacy BIOS/OS ownership handoff",
        "controller stop/reset/run",
        "DCBAA, command ring, event ring, and ERST configuration",
        "connected-port counting and ordinal selection",
        "port reset",
        "Enable Slot",
        "Address Device",
        "endpoint-0 Setup/Data/Status transfers",
        "Device and Configuration descriptor reads",
        "boot HID interface and interrupt-IN endpoint discovery",
        "Configure Endpoint",
        "SET_CONFIGURATION",
        "SET_PROTOCOL boot",
        "Normal TRB HID report receive",
        "nonblocking transfer-event polling",
        "USB usage-to-KeyEvent conversion",
        "boot-mouse-to-PointerEvent conversion",
        "Disable Slot"
      ],
      "dma_contract": [
        "one physically contiguous page-aligned 16-KiB controller region for DCBAA, command ring, event ring, and ERST",
        "one physically contiguous page-aligned 24-KiB region per device for output/input contexts, endpoint-0 ring, descriptor buffer, interrupt-IN ring, and report buffer",
        "the desktop reserves one 64-KiB identity-mapped arena for controller, keyboard, and mouse",
        "controller-coherent DMA mappings owned by the caller"
      ],
      "libraries": [
        "stdlib/freestanding/xhci.sura",
        "stdlib/freestanding/usb_hid.sura",
        "stdlib/freestanding/pointer_event.sura",
        "os/input.sura"
      ],
      "examples": [
        "examples/os/xhci_features.sura",
        "examples/os/usb_hid_features.sura",
        "examples/os/xhci_qemu_gate.sura",
        "examples/os/xhci_mouse_qemu_gate.sura",
        "examples/os/xhci_input_integration_features.sura"
      ],
      "executed_verification": "The keyboard gate enumerates QEMU usb-kbd, injects A, verifies 00 00 04 00 00 00 00 00 and its KeyEvent; the mouse gate selects the second port, enumerates usb-mouse, injects movement, and verifies its raw report and PointerEvent; the full OS gate enumerates both simultaneously, selects xHCI over PS/2, injects Shift and movement, and requires SURA_OS_XHCI_INPUT_READY, SURA_OS_KEYBOARD_OK, and SURA_OS_MOUSE_OK",
      "limitations": [
        "no physical-hardware proof",
        "controllers requiring scratchpad buffers are rejected",
        "desktop device roles currently assume first connected root port is the boot keyboard and second is the boot mouse",
        "no hubs, route strings, arbitrary device order, arbitrary HID report-descriptor parser, or non-boot HID",
        "polling only; no IRQ/MSI",
        "no hot-plug recovery, isochronous transfers, or power management"
      ]
    },
    "virtio_gpu_library": {
      "model": "polling modern VirtIO PCI 2D scanout with a caller-owned split control queue and identity-mapped backing",
      "transport": [
        "PCI device 1af4:1050",
        "vendor-specific common/notify/ISR/device capability mapping",
        "VIRTIO_F_VERSION_1 negotiation",
        "queue-zero descriptor/available/used areas",
        "BAR-relative queue notification"
      ],
      "commands": [
        "GET_DISPLAY_INFO",
        "RESOURCE_CREATE_2D B8G8R8X8_UNORM",
        "RESOURCE_ATTACH_BACKING",
        "SET_SCANOUT",
        "TRANSFER_TO_HOST_2D",
        "RESOURCE_FLUSH",
        "RESOURCE_UNREF"
      ],
      "libraries": [
        "stdlib/freestanding/virtio_pci.sura",
        "stdlib/freestanding/virtio_gpu.sura",
        "stdlib/freestanding/framebuffer.sura",
        "os/sura_os.sura"
      ],
      "executed_verification": "The direct QEMU gate disables GOP, transfers a deterministic 640x480 four-color image, captures the VirtIO display, checks five exact RGB samples, and releases the resource. The full OS keeps GOP primary, mirrors full frames and cursor damage to VirtIO, requires SURA_OS_VIRTIO_GPU_READY, and separately boots without the device while requiring SURA_OS_VIRTIO_GPU_FALLBACK.",
      "verification": [
        "examples/os/virtio_gpu_qemu_gate.sura",
        "tools/sura_virtio_gpu_qemu_gate.ps1",
        "tools/sura_os_vm.ps1"
      ],
      "limitations": [
        "QEMU-only; no physical-hardware proof",
        "polling only; no IRQ/MSI-X",
        "one scanout and no cursor queue",
        "no EDID or display hot-plug/config-change recovery",
        "no resource blobs, virgl, Venus, or 3D command submission",
        "no IOMMU mapping"
      ]
    },
    "hda_audio_library": {
      "model": "polling Intel High Definition Audio PCM output with one caller-owned BDL and identity-mapped sample buffer",
      "controller": [
        "PCI class 04/03/00 discovery",
        "BAR0 MMIO",
        "GCTL reset",
        "STATESTS codec discovery",
        "ICOI/ICII/ICIS immediate-command verbs",
        "output stream descriptor reset/run/stop",
        "LPIB progress polling"
      ],
      "codec": [
        "root-node enumeration",
        "Audio Function Group discovery",
        "Audio Output and Pin Complex widget discovery",
        "power state",
        "pin output enable",
        "converter stream/channel assignment",
        "converter format",
        "stereo output amplifier gain"
      ],
      "pcm_contract": [
        "48 kHz",
        "signed 16-bit little-endian",
        "stereo",
        "one 192000-byte BDL entry",
        "caller-owned contiguous 48-page DMA region",
        "stream tag 1"
      ],
      "libraries": [
        "stdlib/freestanding/hda.sura",
        "os/sura_os.sura"
      ],
      "executed_verification": "The direct QEMU gate generates a one-second bipolar square wave, transfers it through the emulated ICH9 HDA output stream, requires LPIB progress, captures the host WAV backend, and parses 48-kHz signed-16 stereo PCM with observed -12000 and +12000 samples. The full OS transfers a bounded startup slice, requires SURA_OS_HDA_AUDIO_READY, and separately boots without the device while requiring SURA_OS_HDA_AUDIO_UNAVAILABLE.",
      "verification": [
        "examples/os/hda_qemu_gate.sura",
        "tools/sura_hda_qemu_gate.ps1",
        "tools/sura_os_vm.ps1"
      ],
      "limitations": [
        "QEMU-only; no physical-hardware proof",
        "polling only; no IRQ/MSI",
        "one fixed-format output stream and one BDL entry",
        "no PCM mixer, application audio service, input capture, jack sensing, unsolicited codec responses, CORB/RIRB command transport, power management, hot-plug recovery, or IOMMU mapping"
      ]
    },
    "acpi_power_library": {
      "model": "conventional ACPI fixed-hardware S5 power-off and FADT reset for the freestanding x86-64 image",
      "discovery": [
        "UEFI ACPI 2.0/1.0 RSDP",
        "checksum-valid FADT and DSDT",
        "X_DSDT with DSDT fallback",
        "bounded static _S5 Name(Package) parsing",
        "legacy or extended PM1a/PM1b control descriptions",
        "FADT RESET_REG and RESET_VALUE"
      ],
      "register_spaces": [
        "System I/O 8/16-bit access",
        "System Memory 8/16-bit access",
        "SMI_CMD ACPI_ENABLE transition when SCI_EN is clear"
      ],
      "os_integration": [
        "SURA_OS_ACPI_POWER_READY",
        "shutdown through PM1 SLP_TYP/SLP_EN",
        "reboot through RESET_REG",
        "SURA_OS_ACPI_POWER_OFF_ARMED",
        "SURA_OS_ACPI_RESET_ARMED",
        "isa-debug-exit fallback only when firmware power control is unavailable"
      ],
      "libraries": [
        "stdlib/freestanding/acpi.sura",
        "stdlib/freestanding/power.sura",
        "os/sura_os.sura",
        "os/user_terminal.sura"
      ],
      "executed_verification": "The direct shutdown gate discovers FADT and DSDT _S5, enables ACPI mode, writes PM1 control, and requires QEMU exit 0. The direct reset gate writes RESET_VALUE through RESET_REG and requires QEMU -no-reboot exit 0. The complete OS gate sends reboot through the persistent CPL-3 Terminal worker and requires SURA_OS_ACPI_RESET_ARMED; the normal VM sends shutdown and requires SURA_OS_ACPI_POWER_OFF_ARMED.",
      "verification": [
        "examples/os/power_shutdown_qemu_gate.sura",
        "tools/sura_power_shutdown_qemu_gate.ps1",
        "examples/os/power_reset_qemu_gate.sura",
        "tools/sura_power_reset_qemu_gate.ps1",
        "tools/sura_os_reboot_qemu_gate.ps1",
        "tools/sura_os_vm.ps1"
      ],
      "limitations": [
        "QEMU/OVMF execution only; no physical-hardware proof",
        "no general AML interpreter or _PTS execution",
        "no hardware-reduced ACPI sleep-control register path",
        "no suspend states, wake-source management, battery telemetry, thermal policy, or CPU performance-state policy",
        "the static AML parser is serialized through fixed scratch storage"
      ]
    },
    "fat32_library": {
      "mount_checks": [
        "boot signature",
        "matching sector geometry",
        "power-of-two cluster size",
        "FAT32 cluster-count range",
        "FAT version and root cluster",
        "overflow and volume bounds"
      ],
      "operations": [
        "cluster-chain traversal",
        "uppercase space-padded 8.3 directory lookup and listing",
        "checked VFAT LFN creation, lookup, listing, rename, and deletion",
        "strict UTF-8 to UTF-16 conversion",
        "255 UTF-16-code-unit long names",
        "collision-checked deterministic 8.3 aliases",
        "malformed-LFN short-alias fallback",
        "complete and partial regular-file read",
        "same-size existing-file overwrite",
        "mirrored FAT-entry update",
        "zeroed cluster allocation",
        "bounded chain free",
        "short-name file and directory creation",
        "regular-file resize with zeroed newly visible bytes",
        "partial regular-file write",
        "same-directory rename",
        "empty-directory and regular-file deletion",
        "flush"
      ],
      "library": "stdlib/freestanding/fat32.sura",
      "example": "examples/os/fat32_features.sura",
      "mutation_gate": [
        "examples/os/fat32_mutation_qemu_gate.sura",
        "tools/sura_fat32_mutation_qemu_gate.ps1",
        "SURA_FAT32_REMOUNT_OK",
        "SURA_FAT32_LFN_UTF8_OK",
        "SURA_FAT32_LFN_CORRUPT_OK",
        "SURA_FAT32_MUTATION_OK"
      ],
      "executed_verification": "A QEMU-booted UEFI image formats a minimum legal FAT32 RAM disk, checks both FAT copies during three-cluster growth, executes sector- and cluster-spanning partial I/O, shrink/regrow zero exposure checks including same-cluster-count truncation, short-name rename, nonempty-directory rejection and tree deletion, then remounts the same bytes through fresh volume state, reads persisted content, deletes the file, and verifies every chain cluster is free. It creates 문서/메모.txt, resolves alias collisions, renames it to 긴 한글 메모 파일.sura, remounts and reads the data, removes the Korean tree, creates and remounts a maximum 255-code-unit name across a newly allocated directory cluster, and verifies a deliberately corrupted LFN checksum is ignored in favor of the short alias. The graphical OS separately mounts its generated FAT32 data image, traverses root and DOCS short names, and still uses fixed-size NOTES/SETTINGS/DESKTOP overwrites.",
      "limitations": [
        "no Unicode normalization or non-ASCII case folding",
        "no general string path parser; the OS supplies bounded click navigation",
        "no cross-directory move",
        "no FAT repair or FSInfo free-count update",
        "no timestamps or permissions",
        "no interrupted-metadata recovery, journaling, or locking",
        "allocation scans from cluster 2 and a failed write can leak space",
        "desktop mutation/LFN integration is pending"
      ]
    },
    "fat32_vfs": {
      "library": "stdlib/freestanding/fat32_vfs.sura",
      "model": "caller-owned mounted FAT32 volume, shared sector/LFN workspace, scratch entry, and fixed exclusive-open handle array",
      "operations": [
        "canonical relative UTF-8 component resolution",
        "root/file/directory stat",
        "UTF-8 directory listing",
        "file and directory creation",
        "open-create/truncate/append",
        "partial read/write with automatic growth",
        "explicit resize",
        "flush and close",
        "same-directory rename",
        "regular-file and empty-directory removal",
        "filesystem sync"
      ],
      "executed_verification": [
        "examples/os/fat32_mutation_qemu_gate.sura",
        "tools/sura_fat32_mutation_qemu_gate.ps1",
        "/문서/메모.txt VFS create/write/stat/list",
        "exclusive duplicate-open rejection",
        "/문서/기록.sura rename and append",
        "nonempty-directory rejection",
        "fresh FAT32 remount and absence check",
        "SURA_FAT32_VFS_UTF8_OK",
        "SURA_FAT32_VFS_REMOUNT_OK"
      ],
      "limitations": [
        "synchronous shared workspace requires caller serialization",
        "one exclusive handle per directory entry",
        "no nonempty recursive deletion",
        "no cross-directory move",
        "no permissions, timestamps, asynchronous I/O, or cache coherence",
        "graphical desktop integration is pending"
      ]
    },
    "partition_libraries": {
      "gpt_checks": [
        "primary or backup header CRC32",
        "usable-LBA and entry-array bounds",
        "nonzero disk GUID",
        "entry geometry",
        "complete partition-entry-array CRC32"
      ],
      "gpt_operations": [
        "indexed entry traversal",
        "sector-spanning entry copy",
        "type-GUID lookup"
      ],
      "mbr_operations": [
        "four primary entries",
        "type-code lookup",
        "boot flag and device-range validation"
      ],
      "unified_lookup": "EFI System Partition through authoritative GPT, with type-0xEF MBR fallback only when neither GPT validates",
      "libraries": [
        "stdlib/freestanding/gpt.sura",
        "stdlib/freestanding/partition.sura"
      ],
      "examples": [
        "examples/os/gpt_features.sura",
        "examples/os/partition_features.sura"
      ],
      "limitations": [
        "no extended MBR/EBR chains",
        "no hybrid-disk reconciliation",
        "no GPT repair",
        "no partition create, resize, or delete",
        "compile and image verification only"
      ]
    },
    "virtual_filesystem_library": {
      "model": "caller-owned fixed-capacity mount table and file objects",
      "paths": "caller-owned canonical absolute UTF-8 byte buffers with explicit lengths; rejects NUL, repeated/trailing separators, and dot segments",
      "operations": [
        "mount",
        "unmount",
        "longest-prefix resolution",
        "open",
        "read",
        "write",
        "whole-file replace when supplied by the backend",
        "append",
        "seek",
        "resize",
        "flush",
        "close",
        "stat",
        "create file or directory",
        "list directory",
        "same-mount rename",
        "bounded allocation-free file or complete directory-tree copy with rollback and descendant rejection",
        "nonrecursive or recursive remove",
        "sync"
      ],
      "library": "stdlib/freestanding/vfs.sura",
      "example": "examples/os/vfs_features.sura",
      "limitations": [
        "no allocation",
        "no internal synchronization",
        "no permissions enforcement or process ownership",
        "no path normalization, current directory, or symbolic links",
        "cross-mount rename is rejected",
        "the standalone mount-dispatch example has compile and image verification; the memfs backend has separate QEMU execution proof"
      ]
    },
    "writable_memory_filesystem": {
      "model": "volatile fixed-capacity hierarchical filesystem with caller-owned node, UTF-8 name-slot, and file-data-slot storage",
      "operations": [
        "create file or directory",
        "open",
        "read",
        "write",
        "atomic whole-file replace",
        "append",
        "resize",
        "flush",
        "close",
        "stat",
        "list",
        "rename across directories",
        "nonrecursive remove",
        "recursive remove"
      ],
      "utf8_validation": [
        "rejects NUL and slash inside components",
        "rejects dot and dot-dot components",
        "rejects truncated, overlong, surrogate, and out-of-range UTF-8"
      ],
      "libraries": [
        "stdlib/freestanding/vfs.sura",
        "stdlib/freestanding/memfs.sura"
      ],
      "example": "examples/os/memfs_features.sura",
      "executed_verification": [
        "tools/sura_memfs_qemu_gate.ps1",
        "UEFI execution in QEMU",
        "Korean directory and file names",
        "exact write/read",
        "atomic whole-file replacement with one generation change",
        "resize",
        "directory listing",
        "rename",
        "append",
        "bounded complete directory-tree copy",
        "exact copied 21-byte file",
        "copy-into-descendant rejection",
        "open-create",
        "open-truncate",
        "nonrecursive rejection",
        "recursive deletion",
        "SURA_MEMFS_UTF8_OK",
        "SURA_MEMFS_COPY_TREE_OK",
        "SURA_MEMFS_MUTATION_OK"
      ],
      "limitations": [
        "volatile memory only when used without SuraFS",
        "fixed node count, name-slot size, and per-file data-slot size",
        "no allocation",
        "no sparse extents",
        "no symbolic links",
        "no permissions enforcement or process ownership",
        "no timestamps beyond monotonic mutation generations",
        "no internal synchronization, journaling, crash recovery, or persistent disk format by itself",
        "not exposed as a separate volatile graphical desktop mount"
      ]
    },
    "surafs_persistent_foundation": {
      "model": "fixed-capacity persistent filesystem using alternating complete copy-on-write banks and one checksummed superblock per bank",
      "commit_order": [
        "write inactive metadata/data bank",
        "flush block device",
        "publish inactive-bank superblock",
        "flush block device"
      ],
      "recovery": "mount validates both superblock and whole-bank CRC32 values, then selects the newest intact generation; a corrupt newest bank falls back to the prior generation",
      "operations": [
        "UTF-8 file and directory creation",
        "read",
        "write",
        "atomic whole-file replace",
        "append",
        "resize",
        "stat",
        "directory listing",
        "rename",
        "nonrecursive remove",
        "recursive remove",
        "graphical File Explorer directory navigation and file opening",
        "graphical file and folder creation",
        "graphical inline UTF-8 rename",
        "graphical recycle-bin transfer and permanent deletion inside /휴지통",
        "graphical Ctrl+C/Ctrl+X/Ctrl+V file and complete directory-tree copy/move with bounded conflict suffixes",
        "graphical Text Editor UTF-8 cursor, selection highlight, Ctrl+A/C/X/V range editing, autosave, Save As, and .sura lexical highlighting"
      ],
      "graphical_layout": [
        "128 MiB AHCI data disk",
        "legacy FAT32 settings/desktop partition retained",
        "type-0x7f SuraFS partition at LBA 131072",
        "32 nodes",
        "64-byte UTF-8 name slots",
        "4096-byte per-file data slots",
        "/문서/메모.txt default document",
        "/휴지통 recycle-bin directory"
      ],
      "libraries": [
        "stdlib/freestanding/block.sura",
        "stdlib/freestanding/ahci.sura",
        "stdlib/freestanding/vfs.sura",
        "stdlib/freestanding/memfs.sura",
        "stdlib/freestanding/surafs.sura",
        "os/storage.sura",
        "os/sura_os.sura"
      ],
      "example": "examples/os/surafs_qemu_gate.sura",
      "executed_verification": [
        "tools/sura_surafs_qemu_gate.ps1",
        "UEFI execution in QEMU",
        "Korean directory and file names",
        "alternating generations",
        "intentional newest-bank corruption",
        "previous-generation content recovery",
        "post-recovery append and deletion",
        "SURA_SURAFS_RECOVERY_OK",
        "SURA_SURAFS_MUTATION_OK",
        "tools/sura_surafs_gui_qemu_gate.ps1",
        "AHCI-backed graphical editor save through one atomic VFS replace per save",
        "graphical Korean directory navigation and file open",
        "graphical temp directory creation and /휴지통 transfer",
        "graphical agent.sura creation and renamed.sura persistence",
        "graphical 한글.sura creation through Korean composition",
        "more than six persisted directory entries with Home/End viewport scrolling",
        "Explorer Ctrl+C exact 43-byte UTF-8 file copy",
        "Explorer Ctrl+X cross-directory move into movebox",
        "recursive movebox - Copy directory-tree duplication with a second exact 43-byte file",
        "Text Editor Ctrl+A selection",
        "Text Editor Ctrl+C exact 43-byte clipboard copy",
        "Text Editor Ctrl+X CPL-3 range deletion",
        "Text Editor Ctrl+V bounded payload restoration",
        "exact /문서/copy.sura Save As duplicate after clipboard restoration",
        "bounded .sura syntax-color map for keywords, strings, comments, and numbers",
        "active editor path isolation from Explorer navigation scratch paths",
        "exact multiline ASCII-plus-Korean UTF-8 editor payload inspection",
        "remount-only second boot",
        "restored byte length and weighted checksum",
        "unchanged SuraFS generation and complete partition SHA-256",
        "SURA_OS_SURAFS_READY",
        "SURA_OS_SURAFS_CREATE_OK",
        "SURA_OS_SURAFS_RENAME_OK",
        "SURA_OS_SURAFS_TRASH_OK",
        "SURA_OS_FILES_COPY_READY",
        "SURA_OS_FILES_CUT_READY",
        "SURA_OS_FILES_PASTE_OK",
        "SURA_OS_EDITOR_SELECTION_OK",
        "SURA_OS_EDITOR_COPY_OK",
        "SURA_OS_EDITOR_CUT_OK",
        "SURA_OS_EDITOR_PASTE_OK",
        "SURA_OS_EDITOR_SYNTAX_OK",
        "SURA_OS_FILES_SCROLL_OK",
        "SURA_OS_SURAFS_SAVE_AS_OK",
        "SURA_OS_SURAFS_EDITOR_SAVE_OK",
        "SURA_OS_SURAFS_FILE_OPEN_OK",
        "SURA_OS_SURAFS_EDITOR_RESTORED bytes=43 checksum=103782"
      ],
      "limitations": [
        "whole-bank commits rather than extent-level copy-on-write",
        "fixed node count, UTF-8 name-slot size, and per-file data-slot size selected at format time",
        "no dynamic extent allocator or sparse files",
        "no permissions enforcement, ownership, links, internal locking, encryption, compression, online resize, bad-block handling, or background scrub",
        "CRC32 detects corruption but is not cryptographic authentication",
        "QEMU AHCI execution only; not installed or tested on a physical disk"
      ]
    },
    "png_decode_foundation": {
      "model": "allocation-free bounded PNG-to-RGBA8 decoder with caller-owned output and workspace",
      "supported": [
        "non-interlaced PNG",
        "8-bit grayscale",
        "8-bit grayscale-alpha",
        "8-bit RGB",
        "8-bit RGBA",
        "consecutive multiple IDAT chunks",
        "zlib-wrapped DEFLATE",
        "PNG filters 0 through 4",
        "unknown ancillary chunk skipping"
      ],
      "validation": [
        "PNG signature",
        "IHDR ordering and exact size",
        "bounded dimensions and arithmetic",
        "CRC32 for every chunk",
        "critical-chunk rejection",
        "IDAT ordering",
        "IEND placement",
        "zlib CMF/FLG",
        "Adler-32",
        "exact decompressed scanline size",
        "caller output and workspace bounds"
      ],
      "libraries": [
        "stdlib/freestanding/gzip.sura",
        "stdlib/freestanding/png.sura"
      ],
      "executed_verification": [
        "examples/os/png_qemu_gate.sura",
        "tools/sura_png_qemu_gate.ps1",
        "two consecutive IDAT chunks",
        "all PNG filter types 0 through 4",
        "exact 3x5 RGB-to-RGBA pixels",
        "CRC corruption rejection",
        "output-capacity rejection",
        "workspace-capacity rejection",
        "SURA_PNG_DECODE_OK after ExitBootServices"
      ],
      "limitations": [
        "no palette color type",
        "no sub-8-bit or 16-bit samples",
        "no Adam7 interlacing",
        "no color-profile or gamma processing",
        "the browser has a two-slot image path; the full QEMU gate executes a large live suralang.site PNG fetch, decode, layout, and paint"
      ]
    },
    "jpeg_decode_foundation": {
      "model": "allocation-free bounded 8-bit baseline sequential Huffman JPEG-to-RGBA8 decoder with caller-owned output and 16-KiB workspace",
      "supported": [
        "one-component grayscale",
        "three-component YCbCr",
        "1x1 through 2x2 sampling factors",
        "4:4:4",
        "4:2:2",
        "4:2:0",
        "8-bit quantization tables",
        "canonical DC and AC Huffman tables",
        "entropy 0xff/0x00 byte stuffing",
        "integer inverse DCT",
        "nearest-neighbor chroma upsampling",
        "YCbCr-to-RGB conversion"
      ],
      "validation": [
        "SOI and exact terminal EOI",
        "bounded segment lengths",
        "single baseline SOF0",
        "component identity and sampling bounds",
        "quantization-table presence",
        "Huffman-tree oversubscription",
        "scan component uniqueness and table presence",
        "baseline spectral-selection fields",
        "coefficient run and category bounds",
        "caller output and workspace capacity"
      ],
      "libraries": [
        "stdlib/freestanding/jpeg.sura"
      ],
      "executed_verification": [
        "examples/os/jpeg_qemu_gate.sura",
        "tools/sura_jpeg_qemu_gate.ps1",
        "AC-bearing 8x8 4:4:4 color gradient",
        "16x16 4:2:0 image with four luminance blocks",
        "8x8 grayscale image",
        "dimension and alpha checks",
        "bounded per-channel color checks",
        "malformed marker rejection",
        "output-capacity rejection",
        "workspace-capacity rejection",
        "SURA_JPEG_DECODE_OK after ExitBootServices"
      ],
      "limitations": [
        "no progressive JPEG",
        "no arithmetic coding",
        "nonzero restart intervals are rejected",
        "no CMYK or YCCK",
        "no 12-bit samples",
        "no ICC or color-profile processing",
        "the browser connects the decoder to its two-slot image path; live PNG painting is executed, while live JPEG painting is not a separate gate"
      ]
    },
    "html_dom_foundation": {
      "model": "fixed-capacity allocation-free HTML element/text tree with caller-owned node and attribute arrays and immutable input slices",
      "relationships": [
        "parent",
        "first child",
        "last child",
        "next sibling",
        "current open ancestor"
      ],
      "tags": [
        "html",
        "head",
        "body",
        "div",
        "p",
        "h1 through h6",
        "a",
        "span",
        "br",
        "img",
        "style",
        "script",
        "noscript",
        "meta",
        "link",
        "title",
        "ul",
        "ol",
        "li",
        "section",
        "header",
        "footer",
        "main",
        "nav",
        "form",
        "input",
        "button",
        "label",
        "unknown element preservation"
      ],
      "attributes": [
        "id",
        "class",
        "href",
        "src",
        "alt",
        "style",
        "width",
        "height",
        "type",
        "name",
        "value",
        "rel",
        "hidden",
        "action",
        "method",
        "placeholder",
        "checked",
        "disabled",
        "for",
        "unknown attribute preservation",
        "single-quoted",
        "double-quoted",
        "unquoted",
        "boolean"
      ],
      "parsing": [
        "ASCII-case-insensitive names",
        "UTF-8 text byte preservation",
        "raw script/style text through matching closing tags",
        "comments and declarations skipped",
        "self-closing and void elements",
        "bounded ancestor closing-tag recovery",
        "malformed and capacity failure rejection"
      ],
      "libraries": [
        "stdlib/freestanding/html_dom.sura"
      ],
      "executed_verification": [
        "examples/os/html_dom_qemu_gate.sura",
        "tools/sura_html_dom_qemu_gate.ps1",
        "exact parent/child/sibling tree",
        "Korean UTF-8 text slice",
        "href/src/class/alt attributes",
        "login-shaped form/label/input/button tree",
        "type/name/value/action/method/placeholder/for form attributes",
        "raw script text preserving a JavaScript less-than operator",
        "br, img, and input void elements",
        "comment skipping",
        "node-capacity rejection",
        "attribute-capacity rejection",
        "incomplete-comment rejection",
        "SURA_HTML_DOM_OK after ExitBootServices"
      ],
      "limitations": [
        "the graphical Text Browser uses a bounded 1024-node and 1024-attribute instance and falls back to its older flat tokenizer when DOM preparation fails",
        "this module recognizes form structure and attributes but does not own editable control state or submit forms",
        "no HTML5 adoption-agency/foster-parenting algorithm",
        "raw-text scanning is limited to script/style closing-tag recognition",
        "no entity decoding",
        "no CSS selector matching or box construction in this module"
      ]
    },
    "browser_form_foundation": {
      "model": "allocation-free bounded browser form-control state with caller-owned mutable value slots and immutable DOM name/action/method slices",
      "controls": [
        "text input",
        "password input",
        "checkbox",
        "submit input/button",
        "button",
        "disabled flag",
        "checked flag",
        "nearest ancestor form",
        "pointer focus",
        "Enter submission"
      ],
      "encoding": [
        "application/x-www-form-urlencoded",
        "ASCII alphanumeric and -._~ preserved",
        "space encoded as +",
        "other bytes encoded as uppercase %HH",
        "UTF-8 encoded byte by byte",
        "checked valueless checkbox defaults to on",
        "disabled, unchecked, unnamed, submit, and button controls excluded"
      ],
      "submission": [
        "default/GET action query",
        "HTTP/1.1 POST body",
        "current URL action",
        "absolute HTTP(S) action",
        "root-relative action",
        "301/302/303 continue as GET",
        "307/308 preserve POST body"
      ],
      "libraries": [
        "stdlib/freestanding/browser_form.sura"
      ],
      "integration": [
        "os/network.sura",
        "os/sura_os.sura"
      ],
      "executed_verification": [
        "examples/os/browser_form_qemu_gate.sura",
        "tools/sura_browser_form_qemu_gate.ps1",
        "initial and mutable text/password values",
        "UTF-8 Backspace",
        "checkbox toggle",
        "disabled focus rejection",
        "control-to-form ancestry",
        "exact uppercase percent encoding and + spaces",
        "successful-control filtering",
        "default on checkbox value",
        "serialization-capacity rejection",
        "SURA_BROWSER_FORM_OK after ExitBootServices",
        "SURA_OS_BROWSER_FORM_PAGE_OK",
        "SURA_OS_BROWSER_FORM_FOCUS_OK",
        "SURA_OS_BROWSER_FORM_INPUT_OK",
        "SURA_OS_BROWSER_FORM_SUBMIT_OK after the graphical browser builds POST /login with the serialized body",
        "build/os/SuraOS-browser-form.ppm",
        "build/os/SuraOS-browser-submitted.ppm"
      ],
      "limitations": [
        "32 controls with 128-byte value slots in the graphical browser",
        "serialized request is bounded by the 1024-byte HTTP request buffer",
        "no relative action without a leading slash",
        "no radio groups, textarea, select, file input, multipart/form-data, form validation, submitter name/value inclusion, cookies, sessions, autofill, or complete HTML successful-controls rules"
      ]
    },
    "browser_javascript_foundation": {
      "model": "allocation-free bounded JavaScript source compiler and stack bytecode VM with caller-owned code, constant, binding, stack, global, and scratch storage",
      "values": [
        "undefined",
        "null",
        "boolean",
        "signed 64-bit integer number subset",
        "immutable UTF-8 string slice"
      ],
      "bytecode": [
        "constants",
        "global read/write",
        "pop",
        "duplicate",
        "integer add/subtract/multiply/divide/modulo",
        "unary negate/not",
        "equality and ordering",
        "absolute jump",
        "conditional jump",
        "bounded indirect host call",
        "halt"
      ],
      "source_subset": [
        "integer and unescaped UTF-8 string literals",
        "true",
        "false",
        "null",
        "undefined",
        "let/const/var global declarations",
        "assignment to declared globals",
        "identifier reads",
        "unary ! and -",
        "+ - * / %",
        "== === != !== < <= > >=",
        "parentheses",
        "brace blocks",
        "if/else",
        "line and block comments",
        "exact document.getElementById(string).textContent = expression statement"
      ],
      "integration": [
        "stdlib/freestanding/browser_js.sura",
        "stdlib/freestanding/browser_js_source.sura",
        "stdlib/freestanding/browser_js_dom.sura",
        "stdlib/freestanding/html_dom.sura",
        "os/network.sura",
        "os/sura_os.sura"
      ],
      "graphical_bounds": [
        "16-KiB collected inline source",
        "512 instructions",
        "128 constants",
        "128 bindings/globals",
        "64-value operand stack",
        "8192 executed instructions",
        "32 DOM text-mutation overlays"
      ],
      "executed_verification": [
        "examples/os/browser_js_qemu_gate.sura",
        "tools/sura_browser_js_qemu_gate.ps1",
        "arithmetic, globals, taken branch, string equality, indirect host callback",
        "invalid opcode, stack underflow, constant/global/jump/argument rejection",
        "instruction-budget termination of an infinite jump",
        "SURA_BROWSER_JS_VM_OK after ExitBootServices",
        "examples/os/browser_js_source_qemu_gate.sura",
        "tools/sura_browser_js_source_qemu_gate.ps1",
        "source declarations, expressions, assignment, if/else, strict equality syntax",
        "unknown-name, string-escape, and code-capacity rejection",
        "SURA_BROWSER_JS_SOURCE_OK after ExitBootServices",
        "examples/os/browser_js_dom_qemu_gate.sura",
        "tools/sura_browser_js_dom_qemu_gate.ps1",
        "ID lookup, textContent mutation overlay, replacement and descendant suppression",
        "SURA_BROWSER_JS_DOM_OK after ExitBootServices",
        "SURA_OS_BROWSER_JS_OK after graphical inline script execution",
        "SURA_OS_BROWSER_JS_PAGE_OK after sura.local/javascript loads",
        "SURA_OS_BROWSER_JS_CLICK_OK after pointer hit-testing executes inline onclick and redraws changed text",
        "build/os/SuraOS-browser-javascript.ppm"
      ],
      "failure_isolation": "unsupported or over-capacity inline scripts record a bounded script error and do not abort HTML/CSS layout or page rendering",
      "limitations": [
        "not a complete ECMAScript implementation",
        "integer-only number subset rather than IEEE-754 Number",
        "no string escapes or concatenation",
        "no arrays, objects, general properties, functions, closures, call stack, exceptions, promises, modules, eval, or garbage collector",
        "no external script fetch",
        "DOM writes are limited to exact ID-based textContent replacement",
        "events are limited to parsed inline onclick attributes",
        "onclick currently consumes the click before default link or form behavior",
        "no addEventListener, capture, bubbling, general Event object, timers, fetch, storage, or other Web APIs"
      ]
    },
    "browser_webassembly_foundation": {
      "model": "allocation-free bounded WebAssembly MVP integer parser and interpreter with caller-owned module tables, operand stack, locals, and control stack",
      "sections": [
        "custom",
        "type",
        "function",
        "export",
        "code"
      ],
      "values": [
        "i32",
        "i64"
      ],
      "execution": [
        "direct call",
        "block",
        "loop",
        "if/else",
        "br",
        "br_if",
        "return",
        "local.get",
        "local.set",
        "local.tee",
        "i32/i64 constants",
        "integer comparisons",
        "implemented i32/i64 arithmetic opcodes"
      ],
      "bounds": [
        "strict bounded LEB128",
        "fixed module-table capacity",
        "fixed operand/local/control capacity",
        "configurable call-depth limit",
        "configurable instruction limit"
      ],
      "integration": [
        "stdlib/freestanding/browser_wasm.sura",
        "os/network.sura",
        "HTTP or HTTPS response body magic-byte detection",
        "zero-argument exported run invocation",
        "i32/i64 result rendered as an HTML page",
        "sura.local/webassembly binary fixture returns 42"
      ],
      "executed_verification": [
        "examples/os/browser_wasm_qemu_gate.sura",
        "tools/sura_browser_wasm_qemu_gate.ps1",
        "arithmetic result 36",
        "direct call and both if branches",
        "infinite loop stopped at exactly 16 instructions",
        "bad magic rejection",
        "unsupported memory-section rejection",
        "malformed LEB128 rejection",
        "invalid branch-depth rejection",
        "insufficient table-capacity rejection",
        "SURA_BROWSER_WASM_OK after ExitBootServices",
        "SURA_OS_BROWSER_WASM_OK after graphical binary response execution",
        "SURA_OS_BROWSER_WASM_PAGE_OK after sura.local/webassembly renders result 42",
        "build/os/SuraOS-browser-webassembly.ppm"
      ],
      "validation": "bounded structural validation plus runtime type checks; not the complete WebAssembly specification validator",
      "limitations": [
        "no imports, tables, linear memory, globals, start functions, elements, data, floating point, references, exceptions, threads, or SIMD",
        "no WASI",
        "no JIT",
        "no JavaScript WebAssembly object",
        "no fetch/instantiate integration"
      ]
    },
    "css_computed_style_foundation": {
      "model": "fixed-capacity allocation-free CSS rule parser and DOM computed-style cascade with caller-owned rule, style, output, and scratch arrays",
      "selectors": [
        "tag selector",
        ".class selector",
        "#id selector",
        "compound selectors such as div#hero and .foo.bar",
        "descendant selectors",
        "direct-child selectors",
        "inline style attribute",
        "tag/class/id specificity",
        "equal-specificity source-order override"
      ],
      "properties": [
        "display none/block/inline/inline-block/flex/inline-flex/grid/inline-grid",
        "color",
        "background and background-color",
        "width, height, min-width, max-width, min-height, and max-height",
        "integer px dimensions",
        "width percentages and viewport width",
        "viewport height",
        "bounded calc(<percent> - <px>) widths",
        "margin/padding/border-width longhands",
        "one-to-four-value margin/padding/border-width shorthands",
        "horizontal margin auto",
        "static/relative/absolute/fixed position",
        "signed px or auto top/right/bottom/left offsets",
        "width extraction from border and border-top/right/bottom/left compound shorthands",
        "font-size including bounded clamp(px,vw,px) geometry",
        "line-height including non-negative decimal multipliers",
        "box-sizing content-box/border-box",
        "justify-content",
        "align-items",
        "flex-wrap",
        "flex-direction row/column",
        "gap/row-gap/column-gap",
        "grid-template-columns explicit tokens or repeat(count,...)",
        "#RGB",
        "#RGBA",
        "#RRGGBB",
        "#RRGGBBAA with alpha discarded",
        "transparent",
        "up to 32 global :root custom properties resolved into var(--name) uses",
        "last supported hex color extracted from compound background values"
      ],
      "inheritance": [
        "color",
        "font-size",
        "line-height"
      ],
      "libraries": [
        "stdlib/freestanding/html_dom.sura",
        "stdlib/freestanding/css_style.sura"
      ],
      "executed_verification": [
        "examples/os/css_style_qemu_gate.sura",
        "tools/sura_css_style_qemu_gate.ps1",
        "exact body tag and class values",
        "ID specificity over a later tag rule",
        "compound, descendant, and direct-child matching",
        "inline style override",
        "inherited element and text colors",
        "display:none",
        "four-side margin/padding/border values",
        "compound border and directional border shorthand widths",
        "percentage, viewport, calc-minus-pixel, and min/max dimension resolution",
        "bounded clamp(px,vw,px) minimum/preferred/maximum resolution",
        "decimal line-height multiplier resolution",
        "relative/absolute/fixed position plus signed offsets",
        ":root custom-property collection and var() replacement",
        "4/8-digit hex color handling",
        "compound background final-color extraction",
        "flex/grid property parsing",
        "strict malformed-stylesheet rejection",
        "relaxed at-rule and unsupported-selector skipping",
        "supported selectors retained from comma lists",
        "SURA_CSS_STYLE_OK after ExitBootServices"
      ],
      "limitations": [
        "the graphical Text Browser uses the relaxed parser for inline CSS and one root-relative same-host external stylesheet",
        "custom properties are one global :root table without scoped cascade, fallback, or cycle handling",
        "hex alpha is discarded instead of composited",
        "no attribute, pseudo, or sibling selectors",
        "no !important, named colors, percentage heights, general calc(), em/rem, vertical auto-margin behavior, media queries, general variable-size web-font rendering, sticky position, z-index, or stacking contexts",
        "flex/grid parsing and layout remain bounded subsets"
      ]
    },
    "css_box_layout_foundation": {
      "model": "fixed-capacity allocation-free DOM-to-box geometry pass consuming computed styles and emitting caller-owned CssBox records",
      "geometry": [
        "border-box x/y/width/height",
        "content-box x/y/width/height",
        "outer width/height including margins",
        "content-box and border-box sizing",
        "automatic block width",
        "automatic or explicit height"
      ],
      "flow": [
        "vertical block flow",
        "inline element and text flow",
        "measured-width line wrapping",
        "display:none subtree removal",
        "relative boxes retaining normal flow",
        "absolute boxes using the nearest positioned ancestor",
        "fixed boxes using the viewport",
        "absolute/fixed removal from block/flex/grid flow",
        "bounded flex row/column direction, wrapping, pixel gaps, main-axis distribution, and cross-axis placement",
        "bounded equal-width grid with up to 16 explicit or repeat() columns and pixel gaps",
        "parent/first-child/last-child/next-sibling box links"
      ],
      "libraries": [
        "stdlib/freestanding/html_dom.sura",
        "stdlib/freestanding/css_style.sura",
        "stdlib/freestanding/css_box.sura"
      ],
      "executed_verification": [
        "examples/os/css_box_qemu_gate.sura",
        "tools/sura_css_box_qemu_gate.ps1",
        "exact root/html/body/div/text coordinates and dimensions",
        "margin/padding/border edge arithmetic",
        "fixed-height border-box content dimensions",
        "percentage/calc width plus min/max width and viewport-height clamping",
        "centered horizontal margin:auto distribution",
        "absolute right/top placement inside a relative containing block",
        "absolute box removal from following block flow",
        "hidden paragraph subtree omission",
        "box-capacity rejection",
        "40-pixel inline wrapping across text/span/text",
        "flex wrapping, gap, distribution, direction, and cross-axis cases",
        "grid explicit/repeat column placement with row and column gaps",
        "SURA_CSS_BOX_OK after ExitBootServices"
      ],
      "limitations": [
        "the graphical Text Browser paints at most 64 colored backgrounds, 32 text boxes, 256 complete UTF-8 bytes per text node, and 2048 UTF-8 text bytes per desktop frame",
        "text width approximates Unicode scalar count and font size instead of measuring glyphs",
        "no word breaking, shaping, bidirectional layout, baseline alignment, floats, overflow clipping, margin collapsing, tables, sticky positioning, z-index, stacking contexts, transforms, or complete containing-block behavior",
        "right/bottom placement needs known containing and positioned dimensions",
        "no flex grow/shrink/basis, ordering, reverse direction, align-content, per-item alignment, intrinsic grid tracks, named lines, auto-fit/auto-fill, or spanning",
        "one bounded global layout state makes the pass non-reentrant"
      ]
    },
    "virtio_network_and_browser": {
      "libraries": [
        "stdlib/freestanding/virtio_net.sura",
        "stdlib/freestanding/net.sura",
        "stdlib/freestanding/http1.sura",
        "stdlib/freestanding/gzip.sura",
        "stdlib/freestanding/http_content.sura"
      ],
      "integration": [
        "stdlib/freestanding/browser_form.sura",
        "stdlib/freestanding/browser_js.sura",
        "stdlib/freestanding/browser_js_source.sura",
        "stdlib/freestanding/browser_js_dom.sura",
        "stdlib/freestanding/browser_wasm.sura",
        "os/user_browser.sura",
        "os/network.sura",
        "os/https.sura",
        "os/trust_store.sura",
        "os/sura_os.sura"
      ],
      "window_geometry": "work-area-sized Text Browser window; the earlier 720-by-420 default was removed",
      "address_focus": "pointer click or F6 selects the address field; typing replaces the current address",
      "input_interaction": [
        "clicking page content focuses the Browser window before hit testing",
        "mouse-wheel scrolling targets the Browser under the pointer",
        "a visible vertical scrollbar supports track clicks for page movement",
        "held Backspace redraws each repeated UTF-8 code-point deletion"
      ],
      "incremental_navigation": [
        "uncached address-bar DNS begin without a blocking receive loop",
        "bounded DNS receive polling from the desktop service loop",
        "dotted-decimal IPv4 literal parsing with DNS bypass",
        "TCP SYN begin plus bounded SYN-ACK polling from the desktop service loop",
        "ClientHello send plus bounded TLS outer-record and handshake polling from the desktop service loop",
        "one-shot consumption of a completed authenticated TLS connection by the HTTPS continuation",
        "keyboard and mouse dispatch while DNS, TCP connect, or TLS handshake is pending",
        "copied URL snapshot comparison",
        "F6 or address editing cancels a stale DNS, TCP, or TLS request",
        "scheme-less hostnames default to HTTPS while explicit http:// remains available",
        "response receive/decode and later stylesheet/image TLS connections remain synchronous cooperative paths",
        "F6 records a response-fetch cancel request and the next cooperative poll unwinds before restoring the old document and address focus",
        "other nested Browser address/content/request actions rejected while shared fetch buffers are active",
        "SURA_OS_BROWSER_NAV_ASYNC_BEGIN",
        "SURA_OS_BROWSER_NAV_ASYNC_INPUT_OK",
        "SURA_OS_BROWSER_NAV_ASYNC_DONE",
        "SURA_OS_BROWSER_NAV_TCP_BEGIN",
        "SURA_OS_BROWSER_NAV_TCP_INPUT_OK",
        "SURA_OS_BROWSER_NAV_TCP_DONE",
        "SURA_OS_BROWSER_NAV_TLS_BEGIN",
        "SURA_OS_BROWSER_NAV_TLS_DONE",
        "SURA_OS_BROWSER_NAV_FETCH_BEGIN",
        "SURA_OS_BROWSER_NAV_FETCH_INPUT_OK",
        "SURA_OS_BROWSER_NAV_FETCH_CANCEL_REQUESTED",
        "SURA_OS_BROWSER_NAV_FETCH_CANCELLED_OK"
      ],
      "ring3_request_boundary": [
        "persistent Browser worker with a distinct ProcessAddressSpace CR3",
        "private 384-byte mailbox",
        "copied address snapshot limited to 255 bytes",
        "bounded ASCII scheme/host/path validation",
        "external hosts receive network capability only",
        "sura.local receives no network capability",
        "storage and device capabilities remain denied",
        "initial requests, form actions, and redirect targets are re-authorized",
        "worker fault injection closes and reconstructs only the Browser process/window"
      ],
      "device": [
        "legacy-compatible VirtIO-net PCI discovery",
        "I/O BAR",
        "feature negotiation",
        "two 256-entry split virtqueues",
        "sixty-four posted 2048-byte RX buffers in a 160-KiB DMA region",
        "single polling TX descriptor"
      ],
      "protocols": [
        "Ethernet II",
        "DHCP Discover/Offer/Request/ACK",
        "leased IPv4 address, subnet, gateway, and DNS configuration",
        "ARP request/reply",
        "IPv4 header build and checksum validation",
        "dotted-decimal IPv4 address literals",
        "UDP",
        "DNS A query and compressed-name response traversal",
        "case-insensitive single-host boot-session DNS result cache",
        "TCP SYN/SYN-ACK/ACK",
        "TCP payload acknowledgement and FIN",
        "HTTP/1.1 GET",
        "HTTP/1.1 application/x-www-form-urlencoded POST",
        "Content-Length response framing",
        "Transfer-Encoding: chunked with extensions and trailers",
        "connection-close response framing",
        "gzip content coding with stored, fixed-Huffman, and dynamic-Huffman DEFLATE blocks",
        "TLS 1.3 TCP 443 stream",
        "TLS_AES_128_GCM_SHA256",
        "X25519",
        "RSA-PSS-RSAE-SHA256 CertificateVerify",
        "RSA/SHA-256 X.509 chains",
        "HTTP/1.1 ALPN",
        "up to five absolute, protocol-relative, or root-relative redirects"
      ],
      "browser": [
        "sixth managed TEXT BROWSER window",
        "keyboard-editable ASCII hostname, http:// URL, or https:// URL with path",
        "2-MiB response buffer",
        "shared fail-closed HTTP/HTTPS response framing",
        "in-place chunk decoding",
        "bounded gzip decoding with CRC32 and ISIZE validation",
        "Accept-Encoding: gzip, identity request",
        "two-set Korean composition in URL paths",
        "proportional antialiased printable-ASCII and modern-Hangul address/page rendering",
        "valid UTF-8 page-text preservation",
        "uppercase percent encoding of UTF-8 path bytes",
        "Enter-triggered DNS/TCP/HTTP or HTTPS navigation",
        "HTTP-to-HTTPS redirects",
        "certificate hostname, validity-time, chain, key-usage, basic-constraints, and explicit trust-anchor validation",
        "HTTP header removal",
        "bounded 1024-node and 1024-attribute DOM",
        "raw script/style text scanning",
        "inline style collection",
        "one root-relative same-host external stylesheet fetch",
        "relaxed supported-rule extraction",
        "32-entry :root custom-property resolution",
        "computed style and 1024-box layout with bounded percentage/calc/viewport/min-max dimensions, positioning, and flex/grid subsets",
        "bounded inline JavaScript source collection, compilation, and VM execution with failure isolation",
        "inline onclick hit-testing and execution",
        "32-entry getElementById(...).textContent mutation overlay",
        "bounded WebAssembly MVP integer response detection and zero-argument run export execution",
        "visible background, border, image, and UTF-8 text painting",
        "DOM link hit-testing with same-document fragment and root/absolute navigation",
        "wheel, arrow, Page Up/Down, Home, and End scrolling",
        "device-independent held-key repeat including UTF-8 Backspace",
        "text/password/checkbox/button form controls with pointer focus",
        "application/x-www-form-urlencoded successful-control serialization",
        "default/GET query submission",
        "HTTP/1.1 POST body submission",
        "Enter and submit-button activation",
        "POST-preserving 307/308 and GET-converting 301/302/303 redirects",
        "two-slot same-host PNG/baseline-JPEG fetch/decode/layout/paint",
        "older flat tokenizer fallback",
        "desktop icon and taskbar activation",
        "QMP framebuffer capture",
        "scheme-less hostnames select HTTPS by default; explicit http:// selects plain HTTP"
      ],
      "executed_verification": [
        "tools/sura_http1_qemu_gate.ps1",
        "SURA_HTTP1_FRAMING_OK after partial/complete Content-Length including large bodies, chunk-extension/trailer dechunk, connection-close, no-body, and invalid-framing cases",
        "tools/sura_gzip_qemu_gate.ps1",
        "SURA_GZIP_INFLATE_OK after stored, fixed-Huffman, dynamic-Huffman, CRC32, rejection, and complete HTTP gzip finalization cases",
        "tools/sura_browser_form_qemu_gate.ps1",
        "SURA_BROWSER_FORM_OK after exact successful-control serialization and bounds checks",
        "tools/sura_browser_js_qemu_gate.ps1",
        "SURA_BROWSER_JS_VM_OK after bytecode success and bounded failure paths",
        "tools/sura_browser_js_source_qemu_gate.ps1",
        "SURA_BROWSER_JS_SOURCE_OK after source compilation, execution, and rejection paths",
        "tools/sura_browser_js_dom_qemu_gate.ps1",
        "SURA_BROWSER_JS_DOM_OK after DOM ID lookup and textContent overlay checks",
        "tools/sura_browser_wasm_qemu_gate.ps1",
        "SURA_BROWSER_WASM_OK after bounded MVP integer execution and rejection paths",
        "SURA_OS_NETWORK_READY",
        "SURA_OS_DHCP_OK",
        "SURA_OS_ARP_OK",
        "SURA_OS_UDP_OK",
        "SURA_OS_DNS_OK",
        "SURA_OS_TCP_OK",
        "SURA_OS_HTTP_OK",
        "SURA_OS_BROWSER_APP_OK",
        "SURA_OS_BROWSER_CSS_OK",
        "SURA_OS_BROWSER_FOCUS_OK",
        "SURA_OS_BROWSER_URL_OK after live explicit-http example.org navigation",
        "SURA_OS_BROWSER_HTTPS_OK after live scheme-less suralang.site selects HTTPS, completes incremental TLS 1.3, validates its certificate, and receives an encrypted response",
        "SURA_OS_BROWSER_EXTERNAL_CSS_OK after the live same-host stylesheet fetch",
        "SURA_OS_BROWSER_CSS_VARIABLES_OK after live :root var() resolution",
        "SURA_OS_BROWSER_CSS_POSITION_OK after live positioned-style computation",
        "SURA_OS_BROWSER_DOM_BOX_OK after live DOM/computed-style/box conversion",
        "SURA_OS_BROWSER_DOM_RENDER_OK after bounded background, border, image, and UTF-8 text painting",
        "SURA_OS_BROWSER_IMAGE_PNG_OK",
        "SURA_OS_BROWSER_IMAGE_RENDER_OK",
        "SURA_OS_BROWSER_LINK_OK after live anchor hit-testing",
        "SURA_OS_BROWSER_WHEEL_OK after QEMU xHCI USB mouse injection with PS/2 fallback available",
        "SURA_OS_BROWSER_SCROLL_OK after viewport movement",
        "SURA_OS_KEY_REPEAT_OK after held Page Down",
        "SURA_OS_BROWSER_BACKSPACE_REPEAT_OK after held Backspace deletes UTF-8 code points",
        "SURA_OS_BROWSER_JS_OK after the graphical built-in form page compiles and executes inline JavaScript",
        "SURA_OS_BROWSER_JS_PAGE_OK after sura.local/javascript loads",
        "SURA_OS_BROWSER_JS_CLICK_OK after QEMU clicks its inline onclick button and changes #status textContent",
        "SURA_OS_BROWSER_WASM_OK after graphical binary response execution",
        "SURA_OS_BROWSER_WASM_PAGE_OK after sura.local/webassembly renders result 42",
        "SURA_OS_BROWSER_FORM_PAGE_OK",
        "SURA_OS_BROWSER_FORM_FOCUS_OK",
        "SURA_OS_BROWSER_FORM_INPUT_OK",
        "SURA_OS_BROWSER_FORM_SUBMIT_OK after building POST /login with the serialized body",
        "SURA_OS_BROWSER_KOREAN_INPUT_OK",
        "build/os/SuraOS-browser.ppm",
        "build/os/SuraOS-browser-scrolled.ppm",
        "build/os/SuraOS-browser-form.ppm",
        "build/os/SuraOS-browser-submitted.ppm",
        "build/os/SuraOS-browser-javascript.ppm",
        "build/os/SuraOS-browser-webassembly.ppm",
        "build/os/SuraOS-browser-korean.ppm",
        "SURA_OS_BROWSER_RING3_READY",
        "SURA_OS_BROWSER_RING3_OK after copied address and capability validation",
        "SURA_OS_BROWSER_CR3_OK",
        "SURA_OS_BROWSER_PROCESS_ISOLATED_OK after faultbrowser reconstructs the worker and a real request is re-authorized",
        "SURA_OS_BROWSER_NAV_TCP_BEGIN after the RFC 5737 TEST-NET literal starts a SYN attempt without DNS",
        "SURA_OS_BROWSER_NAV_TCP_INPUT_OK after F6 is dispatched while SYN-ACK is pending",
        "SURA_OS_BROWSER_NAV_TCP_DONE after the replacement live connection completes",
        "SURA_OS_BROWSER_NAV_TLS_BEGIN after ClientHello is sent on the live suralang.site connection",
        "SURA_OS_BROWSER_NAV_TLS_DONE after the authenticated handshake completes incrementally",
        "SURA_OS_BROWSER_NAV_FETCH_BEGIN during live suralang.site response/resource work",
        "SURA_OS_BROWSER_NAV_FETCH_INPUT_OK after QMP pointer movement is dispatched before that fetch completes",
        "SURA_OS_BROWSER_NAV_FETCH_CANCEL_REQUESTED after F6 is dispatched during live response work",
        "SURA_OS_BROWSER_NAV_FETCH_CANCELLED_OK after the synchronous network stack unwinds and the Browser restores its old document"
      ],
      "limitations": [
        "QEMU user networking is the executed environment",
        "polling only",
        "the Ring-3 Browser worker validates request metadata and capabilities; address-bar DNS, the first TCP connect, and the first TLS handshake are incremental desktop-loop states; response decoding, later resource TLS connections, DOM construction, layout, painting, and link/form navigation remain a synchronous kernel call stack whose polling loops cooperatively service input; F6 can request a safe unwind, but other nested Browser edits/clicks/requests stay blocked until shared-buffer work returns",
        "no IPv6",
        "bounded connections without a complete retransmission timer, congestion control, or out-of-order reassembly",
        "HTTP content codings other than identity and gzip are rejected",
        "only one gzip member is accepted",
        "only exact Transfer-Encoding: chunked is accepted",
        "HTTPS has one algorithm profile and six pinned trust anchors: ISRG Root X1, DigiCert Global Root G2, GlobalSign Root CA - R3, Amazon Root CA 1, USERTrust RSA Certification Authority, and Microsoft RSA Root Certificate Authority 2017; this is not a broad root store",
        "no certificate revocation checking, session resumption, broad cipher/signature negotiation, or arbitrary URL ports",
        "DNS host names remain ASCII because IDNA is not implemented",
        "DNS cache has one entry for the current boot and no TTL or negative caching",
        "UI glyph coverage is printable ASCII plus modern precomposed Hangul",
        "browser CSS supports bounded tag/class/ID compounds, descendant/direct-child matching, global :root variables, width percentages, min/max dimensions, viewport units, horizontal auto margins, relative/absolute/fixed positioning, and one root-relative same-host stylesheet",
        "the two image slots connect same-host PNG/baseline-JPEG fetch, decode, layout, and paint; the full live gate executes PNG, while live JPEG is not a separate gate",
        "forms are bounded to text/password/checkbox/button controls, URL-encoded GET/POST, current/absolute/root-relative actions, and a 1024-byte request buffer; no radio, textarea, select, file/multipart, validation, cookies, sessions, or complete HTML form model",
        "JavaScript is an integer/string/global/expression/if inline-source subset without arrays, general objects/properties, functions, external scripts, or general Web APIs; DOM mutation is one getElementById(...).textContent path and events are inline onclick only",
        "WebAssembly is a bounded MVP integer response runner without imports, memory, tables, globals, floating point, WASI, JIT, JavaScript integration, or complete specification validation",
        "onclick currently consumes a click before default link or form behavior",
        "no scoped CSS variables, percentage heights, general calc(), em/rem sizing, sticky position, z-index/stacking contexts, transforms, overflow clipping, complete flex/grid, cookies, HTTP object cache, history, or downloads"
      ]
    },
    "serial_and_vm_gate": {
      "serial": [
        "16550 initialization",
        "bounded polling",
        "byte read/write",
        "buffer output"
      ],
      "gate": "tools/sura_qemu_boot_gate.ps1",
      "source": "examples/os/qemu_boot_gate.sura",
      "success_marker": "SURA_EXIT_BOOT_SERVICES_OK",
      "limitations": [
        "QEMU and OVMF required for executed boot",
        "compile-only mode is not execution proof",
        "no ACPI UART discovery",
        "no interrupt-driven serial I/O"
      ]
    },
    "minimal_os_integration": {
      "source": "os/sura_os.sura",
      "ui_assets": [
        "os/icons.sura",
        "seven embedded 16x16 palette-index raster images",
        "generated printable-ASCII and modern-Hangul 2-bit antialiased font atlas",
        "desktop, window-title, Start-menu, taskbar, File Explorer, Text Editor, Calculator, and Text Browser rendering"
      ],
      "gate": "tools/sura_os_vm.ps1",
      "output": [
        "build/os/SuraOS.efi",
        "build/os/SuraOS.img",
        "build/os/SuraData.img"
      ],
      "executed_path": [
        "UEFI entry and ExitBootServices",
        "GOP framebuffer with bounded backbuffer",
        "COM1 diagnostics",
        "physical-page self-check",
        "polling xHCI USB boot keyboard and mouse with PS/2 fallback",
        "SURA_OS_XHCI_INPUT_READY plus injected USB key and movement desktop dispatch",
        "recoverable xHCI-to-PS/2 and input-dispatch failure paths instead of kernel-loop termination",
        "proportional antialiased lowercase-ASCII and modern-Hangul UTF-8 rendering",
        "six managed application windows",
        "focus, z-order, drag, bottom-right resize, minimize/taskbar restore, maximize/restore, fullscreen/restore, close, reopen, Start menu, taskbar, and RTC clock",
        "seven persistent CPL-3 desktop processes under one UserProcessScheduler with distinct ProcessAddressSpace CR3 roots, event queues, kernel stacks, W^X code, NX mailboxes/event pages, and guarded user stacks",
        "SURA_OS_USER_SCHEDULER_READY",
        "SURA_OS_USER_PROCESSES_PERSISTENT_OK after all seven workers preserve their saved frame, CR3 root, and kernel stack across real GUI requests",
        "faulted Calculator isolation, address-space reap, fresh worker/event queue, new process ID and CR3, real post-restart Calculator event, and continued Terminal status response",
        "non-yielding Calculator watchdog termination while mouse movement and a separately queued System Information process advance, second automatic reconstruction, real post-restart event, and continued Terminal status response",
        "SURA_OS_USER_PROCESS_RESTARTED",
        "SURA_OS_USER_PROCESS_RESTART_EVENT_OK",
        "SURA_OS_USER_PROCESS_HANG_INPUT_OK",
        "SURA_OS_USER_PROCESSES_CONCURRENT_OK",
        "SURA_OS_USER_PROCESS_BACKGROUND_OK",
        "SURA_OS_USER_PROCESS_HANG_RECOVERED",
        "ICH9 AHCI discovery and ATA IDENTIFY",
        "staged DMA reads and writes for caller-owned filesystem buffers",
        "legacy FAT32 settings and desktop-state compatibility",
        "type-0x7f SuraFS partition",
        "UTF-8 /문서/메모.txt File Explorer navigation and Text Editor save/open",
        "non-destructive 62-byte /문서/main.sura starter",
        "Explorer file/folder creation, inline rename, Korean filename composition, /휴지통 transfer, Ctrl+C copy, Ctrl+X move, and bounded recursive directory-tree paste",
        "4096-byte editor state with an 8288-byte three-page Ring-3 mailbox, UTF-8 cursor/selection boundaries, selection highlighting, Ctrl+A/C/X/V editing, Ctrl+F next match, bounded Ctrl+H replacement, .sura lexical colors, LF Enter, UTF-8 Backspace/Delete, cursor-following wrapping, Ctrl+S, and Save As",
        "calculator keyboard input, clickable 4x4 keypad, expression display, keyboard 50 - 31 = 19, and keypad 7 + 5 = 12",
        "SURA_OS_SURAFS_READY",
        "SURA_OS_SURAFS_CREATE_OK",
        "SURA_OS_SURAFS_RENAME_OK",
        "SURA_OS_SURAFS_TRASH_OK",
        "SURA_OS_FILES_COPY_READY",
        "SURA_OS_FILES_CUT_READY",
        "SURA_OS_FILES_PASTE_OK",
        "SURA_OS_EDITOR_SELECTION_OK",
        "SURA_OS_EDITOR_COPY_OK",
        "SURA_OS_EDITOR_CUT_OK",
        "SURA_OS_EDITOR_PASTE_OK",
        "SURA_OS_EDITOR_FIND_OK",
        "SURA_OS_EDITOR_REPLACE_OK",
        "SURA_OS_EDITOR_SYNTAX_OK",
        "SURA_OS_CALCULATOR_KEYPAD_OK",
        "SURA_OS_CALCULATOR_KEYPAD_RESULT_OK",
        "SURA_OS_SURAFS_SAVE_AS_OK",
        "SURA_OS_SURAFS_EDITOR_SAVE_OK",
        "SURA_OS_SURAFS_FILE_OPEN_OK",
        "SURA_OS_SURAFS_EDITOR_RESTORED bytes=43 checksum=103782",
        "exact graphical filesystem nodes, file/tree copies, editor clipboard restoration, Save As duplicate, and multiline ASCII-plus-Korean payload persistence across a remount-only second boot",
        "VirtIO-net split queues",
        "DHCP, ARP, IPv4, UDP, DNS, TCP, HTTP/1.1 Content-Length/chunked/connection-close framing, and the bounded TLS 1.3 HTTPS profile",
        "single-host boot-session DNS cache",
        "keyboard-editable browser URL",
        "live non-default-host explicit-http example.org navigation",
        "live scheme-less suralang.site HTTPS selection, incremental TLS handshake, certificate validation, encrypted response, and render through SURA_OS_BROWSER_HTTPS_OK",
        "bounded WebAssembly MVP integer response execution through zero-argument run, rendered result 42, SURA_OS_BROWSER_WASM_OK, and SURA_OS_BROWSER_WASM_PAGE_OK",
        "two-set Korean composition and proportional antialiased rendering in the address bar and UTF-8 page body",
        "bounded h1/p/br/a HTML layout",
        "CSS body/div/h1/a selector colors",
        "64-entry kernel input-event queue round trip",
        "46x14 graphical terminal wrap, scroll, clear, shutdown, and reboot commands",
        "ACPI S5 power-off and FADT RESET_REG reboot",
        "NVMe-first data-disk selection with AHCI fallback, FAT32 settings, and SuraFS document mount",
        "dedicated persistent Ring-3 Window Server with its own CR3, event queue, kernel stack, and bounded two-surface damage compositor",
        "real GOP backbuffer pages mapped into the Window Server ProcessAddressSpace, followed by a verified pixel read/write and restoration",
        "SURA_OS_WINDOW_SERVER_RING3_READY, SURA_OS_WINDOW_SERVER_CR3_OK, SURA_OS_WINDOW_SERVER_SHARED_BUFFER_OK, and SURA_OS_WINDOW_SERVER_RING3_OK",
        "dedicated persistent Ring-3 Browser request validator with its own CR3, event queue, kernel stack, and private 384-byte URL/capability mailbox",
        "SURA_OS_BROWSER_RING3_READY, SURA_OS_BROWSER_RING3_OK, SURA_OS_BROWSER_CR3_OK, and SURA_OS_BROWSER_PROCESS_ISOLATED_OK"
      ],
      "desktop_ring3_workers": {
        "system_information": [
          "process-owned W^X code",
          "writable/NX mailbox",
          "guarded stack",
          "distinct ProcessAddressSpace CR3",
          "CPL-3 bounded framebuffer/free-page/storage/network snapshot validation",
          "display-safe memory and pixel derivation",
          "ring-0 hardware gathering and rendering",
          "SURA_OS_SYSTEM_RING3_READY",
          "SURA_OS_SYSTEM_RING3_OK",
          "SURA_OS_SYSTEM_CR3_OK"
        ],
        "terminal": [
          "process-owned W^X code",
          "writable/NX mailbox",
          "guarded stack",
          "distinct ProcessAddressSpace CR3",
          "CPL-3 bounded line editing and command recognition",
          "ring-0 rendering and privileged command execution after return",
          "SURA_OS_TERMINAL_RING3_READY",
          "SURA_OS_TERMINAL_RING3_OK",
          "SURA_OS_TERMINAL_CR3_OK"
        ],
        "file_explorer": [
          "process-owned W^X code",
          "writable/NX mailbox",
          "guarded stack",
          "distinct ProcessAddressSpace CR3",
          "CPL-3 bounded selection validation",
          "ring-0 SuraFS VFS traversal, mutation, recycle-bin transfer, and UTF-8 rendering after return",
          "SURA_OS_FILES_RING3_READY",
          "SURA_OS_FILES_RING3_OK",
          "SURA_OS_FILES_CR3_OK"
        ],
        "text_editor": [
          "process-owned W^X code",
          "writable/NX three-page mailbox",
          "guarded stack",
          "distinct ProcessAddressSpace CR3",
          "CPL-3 packed UTF-8 insertion, selection replacement, range deletion, Backspace, Delete, clipboard-payload, and bounded replace state transitions",
          "ring-0 selection rendering, find-match selection, clipboard ownership, .sura lexical syntax map, SuraFS autosave, and Save As persistence after return",
          "SURA_OS_EDITOR_RING3_READY",
          "SURA_OS_EDITOR_RING3_OK",
          "SURA_OS_EDITOR_CR3_OK",
          "SURA_OS_EDITOR_FIND_OK",
          "SURA_OS_EDITOR_REPLACE_OK",
          "SURA_OS_EDITOR_SYNTAX_OK"
        ],
        "calculator": [
          "process-owned W^X code",
          "writable/NX mailbox",
          "guarded stack",
          "distinct ProcessAddressSpace CR3",
          "CPL-3 state transitions for keyboard 50 - 31 = 19 and graphical-keypad 7 + 5 = 12",
          "SURA_OS_CALCULATOR_RING3_READY",
          "SURA_OS_CALCULATOR_RING3_OK",
          "SURA_OS_CALCULATOR_CR3_OK",
          "SURA_OS_CALCULATOR_KEYPAD_RESULT_OK"
        ],
        "window_server": [
          "process-owned W^X code",
          "writable/NX mailbox",
          "guarded stack",
          "distinct ProcessAddressSpace CR3",
          "bounded 16x16 two-surface damage composition",
          "mapped real GOP backbuffer pages",
          "verified pixel read, write, and original-value restoration",
          "SURA_OS_WINDOW_SERVER_RING3_READY",
          "SURA_OS_WINDOW_SERVER_CR3_OK",
          "SURA_OS_WINDOW_SERVER_SHARED_BUFFER_OK",
          "SURA_OS_WINDOW_SERVER_RING3_OK"
        ],
        "browser": [
          "process-owned W^X code",
          "private writable/NX 384-byte mailbox",
          "guarded stack",
          "distinct ProcessAddressSpace CR3",
          "copied address, scheme, host, and path validation",
          "network capability for external hosts and no network capability for sura.local",
          "storage and device capability denial",
          "initial, form-action, and redirect authorization",
          "isolated fault recovery with a new process ID and CR3",
          "SURA_OS_BROWSER_RING3_READY",
          "SURA_OS_BROWSER_RING3_OK",
          "SURA_OS_BROWSER_CR3_OK",
          "SURA_OS_BROWSER_PROCESS_ISOLATED_OK"
        ]
      },
      "shell_commands": [
        "help",
        "status",
        "mem",
        "about",
        "clear",
        "shutdown",
        "reboot"
      ],
      "hidden_diagnostic_commands": [
        "faultapp",
        "hangapp",
        "faultbrowser"
      ],
      "shell_gate_execution": "the non-interactive QEMU gate sends help, status, mem, about, clear, and shutdown through COM1 and requires ACPI S5 power-off; the complete-OS reboot gate sends reboot through the persistent CPL-3 Terminal worker and requires the FADT reset path; the graphical screenshot gate separately sends faultapp, requires Calculator page-fault isolation, automatic reconstruction with a new process, and one real post-restart event, then sends status; it next sends hangapp, injects mouse movement during the non-yielding user loop, requires watchdog isolation, another reconstruction and real event, then requires another live status before shutdown",
      "interactive_command": ".\\tools\\sura_os_vm.ps1 -Engine .\\build\\SuraLanguage_os_next.exe -Interactive",
      "screenshot_command": ".\\tools\\sura_os_screenshot.ps1 -Engine .\\build\\SuraLanguage_os_next.exe",
      "screenshots": [
        "build/os/SuraOS-windows.ppm after drag",
        "build/os/SuraOS-start-menu.ppm with reopened System Information",
        "build/os/SuraOS-korean-input.ppm after rendered and persisted Korean input",
        "build/os/SuraOS-apps.ppm with File Explorer, antialiased Text Editor, and the clickable Calculator keypad",
        "build/os/SuraOS-browser.ppm with the fetched suralang.site HTTPS body",
        "build/os/SuraOS-browser-scrolled.ppm after live-page scrolling",
        "build/os/SuraOS-browser-form.ppm after pointer focus and mutable form input",
        "build/os/SuraOS-browser-submitted.ppm after URL-encoded POST construction and submission",
        "build/os/SuraOS-browser-javascript.ppm after inline onclick changes #status textContent",
        "build/os/SuraOS-browser-webassembly.ppm after run() returns 42",
        "build/os/SuraOS-browser-korean.ppm after Korean URL-path input",
        "build/os/SuraOS-desktop.ppm after Terminal activation"
      ],
      "execution_environment": "QEMU x86-64 TCG with EDK2/OVMF; interactive COM1 uses an ephemeral 127.0.0.1-only TCP bridge; no host boot or firmware-variable changes",
      "limitations": [
        "graphical desktop milestone, not a complete desktop OS",
        "xHCI, PS/2, AHCI, VirtIO-net, HDA, and COM1 device access remains polling; the APIC kernel-slice path polls input between long user slices",
        "xHCI desktop enumeration assumes fixed root-port ordering; no hub, hot-plug, arbitrary HID, or physical-hardware proof",
        "window composition and bounded Window Server requests exist, but full app-owned presentation and a user-facing background-job API are not complete",
        "uncached address-bar DNS, the first TCP connect, and the first TLS handshake are incremental and cancelable; the later synchronous response/decode/layout call stack cooperatively services desktop input and accepts F6 as a safe fetch-cancel request, but other Browser address edits, content activation, and nested requests wait until shared-buffer work returns or cancellation finishes",
        "fault recovery rebuilds a fresh built-in app worker rather than restoring arbitrary process memory and instruction state",
        "Browser request validation runs in a dedicated Ring-3 worker, but networking, TLS, DOM, layout, rendering, hardware snapshot gathering, privileged terminal actions, FAT32 traversal, and storage persistence remain kernel-owned",
        "fixed kernel-owned Start/taskbar entries",
        "networking has no IPv6, complete TCP retransmission timer, congestion control, or out-of-order reassembly; HTTPS has one TLS 1.3 algorithm profile, six pinned trust anchors rather than a broad root store, no revocation check, and no session resumption",
        "browser HTML/CSS/JavaScript/WebAssembly support is bounded: compound/descendant/direct-child selectors, same-host external CSS, PNG/baseline-JPEG image slots, URL-encoded GET/POST form controls, flex/grid subsets, an inline integer/string/global/expression/if script subset, inline onclick, one getElementById(...).textContent mutation path, and a bounded MVP integer WebAssembly response runner exist; multipart/file forms, broad properties, complete layout, JavaScript objects/functions, general events, Web APIs, WebAssembly memory/imports/WASI, and complete specification validation do not",
        "does not execute every compile-verified freestanding subsystem",
        "HDA is one fixed-format output stream with no application mixer, input capture, or physical-hardware proof"
      ]
    },
    "acpi_madt": {
      "library": "stdlib/freestanding/acpi.sura",
      "example": "examples/os/acpi_features.sura",
      "discovery": [
        "UEFI ACPI 2.0/1.0 GUID",
        "RSDP checksum",
        "XSDT with RSDT fallback",
        "SDT checksum",
        "MADT"
      ],
      "records": [
        "local APIC/x2APIC processors",
        "I/O APICs",
        "interrupt source overrides",
        "local APIC address override"
      ],
      "limitations": [
        "caller-owned fixed buffers",
        "firmware tables must stay mapped",
        "no interrupt routing",
        "does not itself allocate per-CPU state or start processors"
      ]
    },
    "ioapic_library": {
      "discovery_input": "checked ACPI MADT I/O APIC and interrupt-source-override records",
      "operations": [
        "I/O APIC identity/version validation",
        "GSI ownership lookup",
        "ISA polarity and trigger resolution",
        "fixed physical-destination redirection build",
        "masked-first route programming",
        "route mask update"
      ],
      "library": "stdlib/freestanding/ioapic.sura",
      "example": "examples/os/ioapic_features.sura",
      "limitations": [
        "caller maps MMIO uncached and serializes IOREGSEL/IOWIN",
        "8-bit physical APIC destinations only",
        "no logical or lowest-priority delivery",
        "no x2APIC interrupt remapping",
        "no NMI routes or automatic vector allocation",
        "no executed MMIO proof"
      ]
    },
    "boot_disk": {
      "cli": "sura --target uefi-x86_64 --out BOOTX64.EFI --disk-image sura-os.img source.sura",
      "layout": [
        "protective MBR",
        "primary and backup GPT",
        "FAT32 EFI System Partition"
      ],
      "payload": "EFI/BOOT/BOOTX64.EFI",
      "reproducible": true
    },
    "atomics": [
      "load",
      "store",
      "exchange",
      "compare_exchange",
      "fetch_add",
      "fetch_sub",
      "fences"
    ],
    "interrupts": {
      "declarations": [
        "func name(frame: ptr[Frame]) interrupt do",
        "func name(frame: ptr[Frame]) interrupt_error do"
      ],
      "saved_state": "all x86-64 general-purpose registers plus normalized error code and hardware RIP/CS/RFLAGS frame",
      "return": "IRETQ after register restoration",
      "gate_helper": "cpu.idt_set_gate(table, vector, addr_of(handler), selector, ist, attributes)",
      "compile_time_checks": [
        "direct interrupt-function address",
        "vector error-code ABI",
        "vector/selector/IST/attributes ranges"
      ]
    },
    "surafs_verification_files": [
      "stdlib/freestanding/surafs.sura",
      "examples/os/surafs_qemu_gate.sura",
      "tools/sura_surafs_qemu_gate.ps1",
      "os/storage.sura",
      "os/sura_os.sura",
      "tools/sura_surafs_gui_qemu_gate.ps1",
      "tools/sura_os_data_disk.ps1"
    ],
    "surafs_gui_verification": [
      "fresh 128 MiB data image",
      "AHCI-backed first boot",
      "graphical editor mutation",
      "graphical UTF-8 directory navigation",
      "graphical UTF-8 file open",
      "temp directory creation and recycle-bin transfer",
      "agent.sura creation and renamed.sura rename",
      "한글.sura creation through graphical Korean composition",
      "more than six entries with Home/End viewport scrolling",
      "copy.sura Save As with exact 43-byte payload and lexical syntax-color activation",
      "active editor path isolation from Explorer navigation scratch paths",
      "direct active-bank parent/name/content inspection",
      "exact 43-byte multiline ASCII-plus-Korean on-disk payload inspection",
      "persisted second boot",
      "restored bytes=43 and checksum=103782 marker",
      "unchanged generation",
      "unchanged complete SuraFS partition SHA-256"
    ],
    "fat32_mutation_verification_files": [
      "stdlib/freestanding/fat32.sura",
      "stdlib/freestanding/fat32_vfs.sura",
      "examples/os/fat32_mutation_qemu_gate.sura",
      "tools/sura_fat32_mutation_qemu_gate.ps1"
    ],
    "hda_verification_files": [
      "stdlib/freestanding/hda.sura",
      "examples/os/hda_qemu_gate.sura",
      "tools/sura_hda_qemu_gate.ps1",
      "os/sura_os.sura",
      "tools/sura_os_vm.ps1"
    ],
    "power_verification_files": [
      "stdlib/freestanding/power.sura",
      "examples/os/power_shutdown_qemu_gate.sura",
      "examples/os/power_reset_qemu_gate.sura",
      "tools/sura_power_shutdown_qemu_gate.ps1",
      "tools/sura_power_reset_qemu_gate.ps1",
      "tools/sura_os_reboot_qemu_gate.ps1",
      "os/sura_os.sura",
      "os/user_terminal.sura",
      "tools/sura_os_vm.ps1"
    ],
    "persistent_desktop_verification_files": [
      "os/user_worker.sura",
      "os/user_calculator.sura",
      "os/user_text_editor.sura",
      "os/user_file_explorer.sura",
      "os/user_terminal.sura",
      "os/user_system_info.sura",
      "examples/os/persistent_calculator_qemu_gate.sura",
      "tools/sura_persistent_calculator_qemu_gate.ps1",
      "examples/os/persistent_desktop_apps_qemu_gate.sura",
      "tools/sura_persistent_desktop_apps_qemu_gate.ps1"
    ],
    "verification": [
      "tests/os_target_unit.cpp",
      "tests/freestanding_import_unit.cpp",
      "tools/sura_uefi_target_smoke.ps1",
      "tools/sura_ap_startup_smoke.ps1",
      "tools/sura_qemu_boot_gate.ps1",
      "tools/sura_integer_semantics_qemu_gate.ps1",
      "tools/sura_sha384_qemu_gate.ps1",
      "tools/sura_tls_crypto_qemu_gate.ps1",
      "tools/sura_trust_store_qemu_gate.ps1",
      "tools/sura_ring3_qemu_gate.ps1",
      "tools/sura_ipc_qemu_gate.ps1",
      "tools/sura_process_syscall_qemu_gate.ps1",
      "tools/sura_process_wait_qemu_gate.ps1",
      "tools/sura_user_process_qemu_gate.ps1",
      "tools/sura_user_process_kernel_slice_qemu_gate.ps1",
      "tools/sura_persistent_calculator_qemu_gate.ps1",
      "tools/sura_text_input_qemu_gate.ps1",
      "tools/sura_memfs_qemu_gate.ps1",
      "tools/sura_fat32_mutation_qemu_gate.ps1",
      "tools/sura_input_layout_qemu_gate.ps1",
      "tools/sura_xhci_qemu_gate.ps1",
      "tools/sura_xhci_mouse_qemu_gate.ps1",
      "tools/sura_virtio_gpu_qemu_gate.ps1",
      "tools/sura_os_foundation_verify.ps1",
      "tools/sura_os_vm.ps1",
      "tools/sura_os_screenshot.ps1",
      "tools/sura_os_data_disk.ps1",
      "os/sura_os.sura",
      "os/input.sura",
      "os/user_worker.sura",
      "os/user_system_info.sura",
      "os/user_terminal.sura",
      "os/user_file_explorer.sura",
      "os/user_text_editor.sura",
      "os/user_calculator.sura",
      "os/storage.sura",
      "os/network.sura",
      "os/https.sura",
      "os/trust_store.sura",
      "stdlib/freestanding/sha256.sura",
      "stdlib/freestanding/sha384.sura",
      "stdlib/freestanding/hkdf_sha256.sura",
      "stdlib/freestanding/aes128_gcm.sura",
      "stdlib/freestanding/x25519.sura",
      "stdlib/freestanding/tls13_record.sura",
      "stdlib/freestanding/tls13_handshake.sura",
      "stdlib/freestanding/tls13_hello.sura",
      "stdlib/freestanding/tls13_messages.sura",
      "stdlib/freestanding/tls13_verify.sura",
      "stdlib/freestanding/rsa_public.sura",
      "stdlib/freestanding/rsa_sha256.sura",
      "stdlib/freestanding/rsa_sha384.sura",
      "stdlib/freestanding/der.sura",
      "stdlib/freestanding/x509.sura",
      "stdlib/freestanding/x509_chain.sura",
      "stdlib/freestanding/process_memory.sura",
      "stdlib/freestanding/ipc.sura",
      "stdlib/freestanding/process_syscall.sura",
      "stdlib/freestanding/key_event.sura",
      "stdlib/freestanding/pointer_event.sura",
      "stdlib/freestanding/usb_hid.sura",
      "stdlib/freestanding/text_input.sura",
      "stdlib/freestanding/memfs.sura",
      "stdlib/freestanding/fat32.sura",
      "stdlib/freestanding/fat32_vfs.sura",
      "stdlib/freestanding/virtio_net.sura",
      "stdlib/freestanding/virtio_pci.sura",
      "stdlib/freestanding/virtio_gpu.sura",
      "stdlib/freestanding/net.sura",
      "stdlib/freestanding/framebuffer.sura",
      "stdlib/freestanding/font5x7.sura",
      "stdlib/freestanding/font_hangul.sura",
      "stdlib/freestanding/text_terminal.sura",
      "stdlib/freestanding/window_manager.sura",
      "stdlib/freestanding/desktop_shell.sura",
      "stdlib/freestanding/desktop_apps.sura",
      "stdlib/freestanding/rtc.sura",
      "stdlib/freestanding/ps2.sura",
      "stdlib/freestanding/xhci.sura",
      "examples/os/sha384_qemu_gate.sura",
      "examples/os/trust_store_qemu_gate.sura",
      "examples/os/tls_crypto_qemu_gate.sura",
      "examples/os/integer_semantics_qemu_gate.sura",
      "examples/os/virtio_gpu_qemu_gate.sura",
      "examples/os/framebuffer_features.sura",
      "examples/os/text_terminal_features.sura",
      "examples/os/window_manager_features.sura",
      "examples/os/desktop_shell_features.sura",
      "examples/os/desktop_apps_features.sura",
      "examples/os/rtc_features.sura",
      "examples/os/ps2_features.sura",
      "examples/os/usb_hid_features.sura",
      "examples/os/xhci_input_integration_features.sura",
      "examples/os/xhci_mouse_qemu_gate.sura",
      "examples/os/text_input_features.sura",
      "examples/os/memfs_features.sura",
      "examples/os/fat32_mutation_qemu_gate.sura",
      "examples/os/freestanding_features.sura",
      "examples/os/memory_kernel.sura",
      "examples/os/process_elf_features.sura",
      "examples/os/user_process_features.sura",
      "examples/os/user_process_qemu_gate.sura",
      "examples/os/user_process_kernel_slice_qemu_gate.sura",
      "examples/os/persistent_calculator_qemu_gate.sura",
      "examples/os/ipc_features.sura",
      "examples/os/process_syscall_features.sura",
      "examples/os/process_wait_qemu_gate.sura",
      "examples/os/ring3_qemu_gate.sura",
      "examples/os/scheduler_features.sura",
      "examples/os/preemptive_timer_features.sura",
      "examples/os/syscall_features.sura",
      "examples/os/user_mode_features.sura",
      "examples/os/pci_features.sura",
      "examples/os/pcie_features.sura",
      "examples/os/block_features.sura",
      "examples/os/ahci_features.sura",
      "examples/os/nvme_features.sura",
      "examples/os/xhci_features.sura",
      "examples/os/xhci_qemu_gate.sura",
      "examples/os/gpt_features.sura",
      "examples/os/partition_features.sura",
      "examples/os/fat32_features.sura",
      "examples/os/vfs_features.sura",
      "examples/os/qemu_boot_gate.sura",
      "examples/os/acpi_features.sura",
      "examples/os/ioapic_features.sura",
      "examples/os/ap_startup_features.sura",
      "stdlib/freestanding/font_ui.sura",
      "stdlib/freestanding/font_ui_atlas.sura",
      "stdlib/freestanding/power.sura",
      "stdlib/freestanding/window_server.sura",
      "stdlib/freestanding/ui.sura",
      "os/user_window_server.sura",
      "examples/os/window_server_features.sura",
      "tools/sura_window_server_qemu_gate.ps1",
      "tools/sura_ui_font_generate.ps1",
      "tools/sura_power_shutdown_qemu_gate.ps1",
      "tools/sura_power_reset_qemu_gate.ps1",
      "tools/sura_os_reboot_qemu_gate.ps1",
      "tools/sura_nvme_qemu_gate.ps1",
      "tools/sura_os_nvme_qemu_gate.ps1",
      "examples/os/power_shutdown_qemu_gate.sura",
      "examples/os/power_reset_qemu_gate.sura",
      "examples/os/nvme_qemu_gate.sura",
      "third_party/noto-cjk/OFL.txt",
      "third_party/noto-cjk/NOTICE.md"
    ],
    "not_implemented": [
      "executed AP-startup coverage and complete per-AP initialization lifecycle",
      "automatic per-CPU TSS/IST allocation",
      "FPU/SIMD process context-switch policy",
      "ET_DYN/PIE, relocation, interpreter, dynamic-linking, and TLS executable loading",
      "demand paging, copy-on-write, general user-facing shared-memory APIs, and memory-mapped files",
      "signals and fast-syscall blocking/resume conversion",
      "KPTI, NMI-safe entry, and comprehensive speculative-entry hardening",
      "synchronized/NUMA physical-memory policy",
      "complete virtual address-space policy",
      "PCID and remote TLB shootdown",
      "SMP run queues and load balancing",
      "PCI/PCIe resource allocation, bridge setup, and MSI/MSI-X",
      "production network drivers, general USB hub/hot-plug/non-boot-HID drivers, accelerated graphics, a general application audio mixer/input service, physical audio-driver proof, and other device-specific drivers",
      "IRQ-driven input queues, scheduled-process input delivery, full-size app-owned Ring-3 surfaces, complete user-space composition, window animations, drag-and-drop, real multi-output presentation, and complete accessibility service",
      "extended MBR chains, GPT repair, and partition create/resize/delete",
      "scalable persistent extent allocation, permissions enforcement, links, locking, encryption, online resize, and physical-disk deployment",
      "ARM64 freestanding backend",
      "source-level freestanding debugger",
      "executed CI VM boot coverage"
    ]
  },
  "interop": {
    "ffi_abi": "1.2.0",
    "plugin_abi": "1.1.0",
    "ffi_vm_calls": "serialized because the GC heap is process-global",
    "ffi_handle_lifetime": "monotonic opaque tokens with per-call leases; close is deferred while a call is active",
    "ffi_same_handle_reentry": "a different host thread receives SURA_ERR_BUSY while sura_run owns the handle",
    "ffi_global_commit": "fallible map and GC-root construction completes before the visible globals are swapped",
    "ffi_cross_run_values": {
      "persistent": [
        "nil",
        "bool",
        "number",
        "string",
        "tensor",
        "array/dict whose reachable values are persistent"
      ],
      "run_bound": [
        "function/closure",
        "upvalue",
        "class instance",
        "array/dict that reaches a run-bound value"
      ],
      "successful_run": "top-level globals whose reachable graph is run-bound are omitted from persistent globals",
      "failed_run": "if a failed run inserts a run-bound value into an existing persistent container, that handle clears its persistent globals",
      "graph_scan_limit_objects": 1000000
    },
    "ffi_return_strings": "per-host-thread OS TLS/FLS buffer; valid until the next string/error getter on that thread",
    "ffi_c_boundary": "C-compatible header; every exported function is noexcept and converts native exceptions to status/default values",
    "optional_integrations": {
      "ffmpeg": "local media/video decoding; select with SURA_FFMPEG or --ffmpeg where supported",
      "curl": "native HTTP, async HTTP, and HTTP-backed LLM requests",
      "nodejs": "JavaScript target and VS Code tooling; required by http.serve_routes and preferred by http.serve_static",
      "python": "Python bridge and http.serve_static fallback",
      "c_cpp_toolchain": "native FFI, plugin, embedding, and generated binding builds",
      "cuda_driver_and_optional_cublas": "CUDA tensor operations"
    }
  },
  "verification": {
    "public_report": "/downloads/verification-1.11.1.json",
    "schema": "sura.public.verification.v1",
    "product": "Sura Language",
    "version": "1.11.1",
    "verified": "2026-07-15",
    "engine_file": "SuraLanguage.exe",
    "engine_sha256": "a735688c2f11de4e33b768c3aa2cdcfba7278e7d2d4b722d7144c6208cf10fe7",
    "engine_bytes": 8518877,
    "engine_locations_checked": [
      "repository build",
      "generated installer kit",
      "single-file installer smoke installation"
    ],
    "package_helper": {
      "file": "surapkg.exe",
      "bytes": 5372032,
      "sha256": "a7640f81268b7be834d08134afdb222bb74beb507e774ccac3146e4257594cfb"
    },
    "results": {
      "stable_vm": "107/107 PASS",
      "stable_jit": "107/107 PASS",
      "core_vm": "107/107 PASS",
      "core_jit": "107/107 PASS",
      "bytecode_validation": "not rerun as a standalone suite; stable VM/JIT suites PASS",
      "ffi_safety": "not rerun as a standalone suite; stable VM/JIT suites PASS",
      "async_runtime_concurrency": "stable VM/JIT async cases PASS; dedicated async race regression retained",
      "release_payload_identity": "installer smoke verified generated kit, locked-upgrade handling, single-file installation, execution, and uninstall",
      "starter_examples": "12/12 parse, typecheck, and run PASS without optional dependencies",
      "starter_scaffold": "surapkg new, generated package run, and generated package test PASS",
      "target_lowering_audit": "INCOMPLETE; JS full 41 partial 0 ignored 2; WASM full 28 partial 13 ignored 2",
      "installer_smoke": "locked executable rejection, single-file extract, quiet install, UTF-8 execution, and uninstall PASS",
      "vscode_extension": "TypeScript compile, LSP client/fallback smoke, esbuild, and extension smoke PASS",
      "website": "vinext production build PASS",
      "windows_authenticode": "valid 0; unsigned 3; direct warning expected True",
      "store_msix": "package content PASS; local loose-layout smoke not_requested"
    },
    "performance_record": {
      "status": "archived performance record; not rerun for 1.11.1",
      "reason": "This patch release changes JIT coverage, diagnostics, GC observability, editor integration, installer diagnostics, and release tooling; no new C++ comparison is claimed.",
      "previous_public_record": "/downloads/verification-1.10.0.json#performance_record",
      "source": "artifacts/native_perf.json",
      "sha256": "4fc519f0473bcb5265214ef43abe01617343bc8f86e922a18a9c1a8f1e9c34ea",
      "generated_utc": "2026-07-13T04:48:16Z",
      "measured_language_version": "1.10.0",
      "measured_engine_sha256": "2cba8070938783da9622a7f01a80d1a2b78aa21bef6d3142ee21303478dc08c0",
      "measured_engine_bytes": 8438343,
      "host": {
        "os": "Microsoft Windows NT 10.0.26200.0",
        "architecture": "X64",
        "cpu": "12th Gen Intel(R) Core(TM) i5-12400F"
      },
      "compiler_version": "g++.exe (Rev13, Built by MSYS2 project) 15.2.0",
      "compiler_flags": "-O3 -DNDEBUG -std=c++17 -march=native",
      "runs": 30,
      "vec2_sura_jit_ms": 1.935,
      "vec2_cpp_o3_ms": 0.05,
      "vec2_ratio": 38.33,
      "vec3_sura_jit_ms": 5.297,
      "vec3_cpp_o3_ms": 0.05,
      "vec3_ratio": 105.62,
      "target_ratio": 10,
      "target_met": false
    },
    "latest_engineering_records": {
      "release_evidence": {
        "generated_utc": "2026-07-17T05:12:40Z",
        "passed": false,
        "checks": "156/157",
        "source": "/records/release-evidence.json"
      },
      "goal_audit": {
        "generated_utc": "2026-07-17T05:09:34Z",
        "status": "INCOMPLETE",
        "progress_percent": 99.2,
        "checks": "126/127",
        "blockers": 1,
        "source": "/records/goal-audit.json"
      },
      "target_lowering": {
        "generated_utc": "2026-07-17T05:08:33.3412721Z",
        "status": "INCOMPLETE",
        "js": {
          "full": 41,
          "ignored": 2,
          "partial": 0,
          "missing": 0,
          "unknown": 0,
          "complete": true
        },
        "wasm": {
          "full": 27,
          "ignored": 2,
          "partial": 14,
          "missing": 0,
          "unknown": 0,
          "complete": false
        },
        "source": "/records/target-lowering-audit.json"
      }
    }
  },
  "release": {
    "schema": "sura.public.release.v1",
    "product": "Sura Language",
    "version": "1.11.1",
    "published": "2026-07-15",
    "platform": "windows-x64",
    "store": {
      "product_id": "9P5JFKSWTP0P",
      "url": "https://apps.microsoft.com/detail/9P5JFKSWTP0P",
      "publisher": "SuraTeam",
      "availability": "public",
      "pricing": "Free"
    },
    "starter_pack": {
      "command": "surapkg new <name>",
      "generated": [
        "package manifest",
        "source",
        "test",
        "README",
        "VS Code settings"
      ],
      "beginner_examples": 12
    },
    "runtime": {
      "engine": "register VM",
      "optional_jit": {
        "flag": "--jit",
        "platform_abi": "Windows x64 / Win64",
        "mode": "lazy partial compilation inside the register VM",
        "fallback": "unsupported bodies remain in the register VM"
      },
      "diagnostics_default": "English",
      "diagnostics_korean": "--lang ko or SURA_LANG=ko"
    },
    "installer_requirements": [
      "Windows x64",
      ".NET Framework CLR",
      "Windows PowerShell or PowerShell"
    ],
    "optional_integrations": {
      "ffmpeg": "local media and video decoding",
      "curl": "native HTTP, async HTTP, and HTTP-backed LLM requests",
      "nodejs": "JavaScript target, VS Code tooling, http.serve_routes, and preferred http.serve_static runtime",
      "python": "Python bridge and http.serve_static fallback",
      "c_cpp_toolchain": "source build, embedding, FFI bindings, and plugins",
      "cuda_driver_and_optional_cublas": "CUDA tensor operations"
    },
    "signing": {
      "authenticode": "NotSigned",
      "vsix_signature": "Not provided"
    },
    "license": {
      "root_license_file": "Not provided",
      "vscode_package_field": "UNLICENSED"
    },
    "artifacts": [
      {
        "name": "SuraLanguageSetup-1.11.1.exe",
        "bytes": 15038464,
        "sha256": "b88bdb651e4d443064418a88abc6482f305b65339be614d80c4998f8add9c38a"
      },
      {
        "name": "SuraLanguage-1.11.1-windows-x64.zip",
        "bytes": 5359996,
        "sha256": "fed5291869e66a1a0da49d59b31482ef6c2843d32a4f1bb4c0c07ae12c2a3277"
      },
      {
        "name": "SuraLanguage-VSCode-1.11.1.vsix",
        "bytes": 170920,
        "sha256": "86d1dbb4a8efc7459da1a6b8f02af4fed958ffe92433060ccf8bace3a00dae6a"
      }
    ]
  },
  "performance_records": {
    "current_native_baseline": {
      "status": "verified fair-scope record",
      "applies_to_version": "1.11.1",
      "source": "/records/native-performance.json",
      "generated_utc": "2026-08-15T05:14:53Z",
      "engine": {
        "file": "SuraLanguage.exe",
        "version_output": "Sura Language 1.11.1",
        "bytes": 8925231,
        "sha256": "70d97168df605bc68af1354c166cc5d8a509a603fed6d9ed286806830acdd80f"
      },
      "host": {
        "os": "Microsoft Windows NT 10.0.26200.0",
        "architecture": "X64",
        "cpu": "12th Gen Intel(R) Core(TM) i5-12400F"
      },
      "compiler": "g++.exe (Rev13, Built by MSYS2 project) 15.2.0",
      "compiler_flags": "-O3 -DNDEBUG -std=c++17 -march=native",
      "measurement": "100,000-step inner physics loop; 5 Sura runs and 5 native C++ runs",
      "vec2": {
        "sura_jit_ms": 0.07145999697968364,
        "cpp_o3_ms": 0.05026,
        "ratio": 1.4218065455567774
      },
      "vec3": {
        "sura_jit_ms": 0.08996000397019088,
        "cpp_o3_ms": 0.05012,
        "ratio": 1.7948923377931143
      },
      "fair_scope_passed": true
    },
    "latest_published_native_baseline": {
      "status": "archived performance record; not rerun for 1.11.1",
      "applies_to_version": "1.10.0",
      "current_release_measured": false,
      "source": "/downloads/verification-1.11.1.json#performance_record",
      "archived_source": "artifacts/native_perf.json",
      "archived_source_sha256": "4fc519f0473bcb5265214ef43abe01617343bc8f86e922a18a9c1a8f1e9c34ea",
      "generated_utc": "2026-07-13T04:48:16Z",
      "engine": {
        "file": "SuraLanguage.exe",
        "version_output": "Sura Language 1.10.0",
        "bytes": 8438343,
        "sha256": "2cba8070938783da9622a7f01a80d1a2b78aa21bef6d3142ee21303478dc08c0"
      },
      "host": {
        "os": "Microsoft Windows NT 10.0.26200.0",
        "architecture": "X64",
        "cpu": "12th Gen Intel(R) Core(TM) i5-12400F"
      },
      "compiler": "g++.exe (Rev13, Built by MSYS2 project) 15.2.0",
      "compiler_flags": "-O3 -DNDEBUG -std=c++17 -march=native",
      "measurement": "100,000-step inner loop; 30 Sura runs and 30 native runs",
      "vec2": {
        "sura_jit_ms": 1.935,
        "cpp_o3_ms": 0.05,
        "ratio": 38.33
      },
      "vec3": {
        "sura_jit_ms": 5.297,
        "cpp_o3_ms": 0.05,
        "ratio": 105.62
      },
      "target_ratio": 10,
      "target_met": false
    },
    "native_baseline_2026_07_12": {
      "environment": "Windows x64; Intel Core i5-12400F; g++ 15.2.0; 100,000-step inner loop",
      "vec2": {
        "sura_jit_ms": 17.225,
        "cpp_o3_ms": 0.053,
        "ratio": 324.09
      },
      "vec3": {
        "sura_jit_ms": 62.254,
        "cpp_o3_ms": 0.051,
        "ratio": 1221.77
      }
    },
    "historical_gpu_record": {
      "language_version": "1.8",
      "engine_sha256_prefix": "3270a9",
      "hardware": "RTX 4060",
      "source": "Guide/GPU_AND_SCALE.md"
    },
    "current_jit_gaps": [
      "baseline helpers do the whole job for strings, dicts, and objects, so those workloads are still slower than CPython on Linux x86-64",
      "inline caches for field access and method calls outside Win64",
      "ARM64 benchmark table re-measurement",
      "macOS x86-64 native backend",
      "general function and method inlining",
      "general escape analysis beyond guarded 2/3-field no-alias record updates",
      "general register allocation",
      "loop-invariant code motion",
      "loop-carried XMM SSA"
    ]
  },
  "documentation_limits": {
    "api_entries": "528 module entries contain canonical names, call signatures, and source locations; shared runtime limits and module-specific contracts are recorded in the prose and structured sections",
    "global_registry": "664 case-sensitive direct-call names and aliases are enumerated"
  },
  "cli_help": "Sura Language Runtime 1.11.1\r\nUsage:\r\n  sura --version             Show the Sura Language version\r\n  sura --jit-info            Show native JIT OS, architecture, ABI, and fallback\r\n  sura --jit-info-json       Show machine-readable JIT target information\r\n  sura <file.sura> [--] [args...]  Run file with script argv\r\n  sura --repl                Interactive REPL\r\n  sura --dump <file.sura>    Show bytecode\r\n  sura --bench <file.sura>   Benchmark\r\n  sura --strict <file.sura>  Explicitly select the default strict type checking\r\n  sura --legacy-types <file.sura>  Legacy mode: report type warnings and continue\r\n  sura --compile <file.sura>  Compile to .sura.bc (no run)\r\n  sura --release <file.sura>  Build a .sura.srp release container\r\n  sura --release-key <key>    Require key for --release package execution\r\n  sura --release-key-file <path> Read release key from a UTF-8 file\r\n  sura --release-license <license> Require license value for release execution\r\n  sura --release-license-file <path> Read release license from a UTF-8 file\r\n  sura --release-id <id>      Store release/customer id in package metadata\r\n  sura --release-expires YYYY-MM-DD  Expire release package after date\r\n  sura --out <path>           Output path for --compile/--release\r\n  sura --profile <file.sura>  Run with type profiling report\r\n  sura --profile-json out.json <file.sura>  Write machine-readable profile report\r\n  sura --gc-stats <file.sura>  Run a final GC and print pause/object statistics\r\n  sura --gc-stats-json out.json <file.sura>  Write machine-readable GC statistics\r\n  sura --trace <file.sura>    Trace VM instructions\r\n  sura --debug <file.sura>    Dump bytecode, trace, and profile\r\n  sura --debug-protocol <file.sura>  Run line-stop debugger protocol\r\n  sura --lang en|ko           Set diagnostic language (default: English; env SURA_LANG)\r\n  sura --test [path]          Discover and run Sura tests\r\n  sura --test-report out.json [path]  Write machine-readable test results\r\n  sura --check [path]         Parse and typecheck without running\r\n  sura --strict-syntax [path] Reject legacy command-style calls; use name(...)\r\n  sura --ast-json [--out out.json] <file.sura>  Emit machine-readable AST JSON\r\n  sura --lint [path]          Run lightweight static lint checks\r\n  sura --format <path>        Format Sura files in place\r\n  sura --format-check <path>  Check Sura formatting without writing\r\n  sura --jit <file.sura>      Enable native JIT (Win64 x64; VM fallback elsewhere)\r\n  sura --load <file.sura.bc> Run precompiled bytecode\r\n  sura --load-release <file.sura.srp> Run a .sura.srp release container\r\n  sura --load-release-key <key> Key for .sura.srp release container\r\n  sura --load-release-key-file <path> Read release key from a UTF-8 file\r\n  sura --load-release-license <license> License for .sura.srp release container\r\n  sura --load-release-license-file <path> Read release license from a UTF-8 file\r\n  SURA_ALLOW_RELEASE_INSPECT=1 allows dump/trace/debug on protected packages\r\n  sura --lsp                 Language Server mode",
  "package_manager_help": "Sura package manager\r\nUsage:\r\n  surapkg new <name> [--json report.json]  Create a runnable starter project with tests and VS Code settings\r\n  surapkg init [name] [--json report.json]  Create sura.pkg.json and src/<name>.sura\r\n  surapkg create <name> [--json report.json]  Create a package skeleton directory\r\n  surapkg agent <name> [--json report.json]  Create an AI automation agent template\r\n  surapkg embed <name> [--json report.json]  Create a native C++ host embedding template\r\n  surapkg version [path] [major|minor|patch|version] [--json report.json]  Show or update package manifest version\r\n  surapkg install <path|file|name[@version|range]> [--json report.json]  Install local or registry package\r\n  surapkg outdated [name] [--json]  Show installed packages with newer registry versions\r\n  surapkg update [name] [--json report.json]  Update installed packages from the registry\r\n  surapkg publish [path] [--dry-run] [--json report.json]  Validate or publish to local/HTTP registry\r\n  surapkg search [query] [--json]  Search local or HTTP registry index\r\n  surapkg stats [name] [--json]  Show local or HTTP registry download/publish stats\r\n  surapkg analytics [name] [--json]  Show public registry download trends and top packages\r\n  surapkg registry-health [path] [--fail-on-warning] [--json]  Summarize local/HTTP registry health and moderation queues\r\n  surapkg recover-token <user> <recovery-code> [new-token] [--json report.json]  Recover a registry account token\r\n  surapkg owners [name] [--json]  List registry package owners\r\n  surapkg yanks [name] [--json]  List yanked registry package versions\r\n  surapkg advisory <name[@version]> --severity high --title text --description text [--json]  Create a registry security advisory\r\n  surapkg advisories [name[@version]] [--fail-on high] [--json]  List or gate registry security advisories\r\n  surapkg yank <name@version> <reason> [--json]  Yank a bad registry package version\r\n  surapkg unyank <name@version> [reason] [--json]  Restore a yanked registry package version\r\n  surapkg report <name[@version]> <reason> [--json]  Report a package for registry review\r\n  surapkg reports [status] [--json]  List registry abuse reports\r\n  surapkg review-report <id> <status> [note] [--json]  Review an abuse report\r\n  surapkg doctor [path] [--json report.json]  Diagnose local Sura, package, registry, and tooling setup\r\n  surapkg clean [path] [--dry-run] [--json report.json]  Remove safe generated logs and temporary smoke outputs\r\n  surapkg index [--json report.json]  Rebuild registry/index.json\r\n  surapkg lock [--json report.json]  Write sura.lock.json for installed dependency graph\r\n  surapkg sign [path] [--json report.json]  Write sura.pkg.sig integrity/keyed/public-key signature\r\n  surapkg sign-policy [path] [--json report.json]  Write sura.tools.sig for a package tool policy\r\n  surapkg verify [path] [--json report.json]  Verify sura.lock.json or a package signature\r\n  surapkg verify-policy [path] [--json report.json]  Verify sura.tools.sig for a package tool policy\r\n  surapkg verify-registry [path] [--json report.json]  Verify local/HTTP registry index, bundles, signatures, metadata\r\n  surapkg trust-key <id> <pem> [--json report.json]  Trust a public signing key for registry/key-dir verification\r\n  surapkg resolve [--json]     Resolve manifest and transitive deps against packages/local/HTTP registry\r\n  surapkg tree [--json]       Show the resolved dependency tree\r\n  surapkg why <name> [--json] Explain why a dependency is in the resolved graph\r\n  surapkg format [path] [--check] [--json report.json]\r\n  surapkg check [path] [--json report.json] [--strict|--legacy-types]  Strict by default\r\n  surapkg lint [path] [--json report.json] [--fail-on-warning]\r\n  surapkg audit [path] [--json report.json] [--sarif report.sarif]  Scan package source for risky APIs\r\n  surapkg policy [path] [--json report.json]  Generate starter sura.tools.json from package tool specs\r\n  surapkg tool-log <jsonl>     Summarize SURA_TOOL_AUDIT_LOG events; use --json for CI\r\n  surapkg bind-c <header.h> [--json report.json]  Generate Sura ffi_call wrappers from simple C/C++ C-ABI headers\r\n  surapkg docs [outdir] [--json report.json]  Generate package HTML docs, api.json, and search-index.json\r\n  surapkg quality [path] [--json report.json]  Score package readiness for CI/release gates\r\n  surapkg ci [path] [--json report.json]  Generate docs, test, optional bench, audit, verify, and quality-check\r\n  surapkg release [path] [--dry-run] [--json report.json]  Generate docs, test, optional bench, sign, quality-check, and publish\r\n  surapkg protect [path]       Compile package main to protected .sura.srp or embedded launcher exe\r\n  surapkg protect-verify <protect-report.json> [--json report.json]  Verify protected release evidence\r\n  surapkg run [path] [--json run.json] [--] [args...]  Run package manifest main with script argv\r\n  surapkg profile [path] [--json profile.json] [--no-jit] [--] [args...]\r\n  surapkg bench [path] [--json bench.json] [--summary bench.md] [--python script.py] [--min-speedup ratio] [--] [args...]\r\n  surapkg bench-dashboard [--out html] [--json report.json] [--summary summary.md] [--release-notes notes.md] [--native-perf native_perf.json]  Generate benchmark dashboard artifacts\r\n  surapkg test [path] [--json file.json|--report file.json] [--junit file.xml] [--no-jit]\r\n  surapkg remove <name> [--json report.json]  Remove an installed package\r\n  surapkg list [--json]        List stdlib, installed packages, and manifest deps\r\n  surapkg info <name> [--json] Show package metadata, benchmark evidence, and exported symbols\r\n  surapkg restore [--json report.json]  Install manifest and transitive dependencies locally"
}