DOCUMENTATION / VERSION 1.10.0

Sura 언어
레퍼런스

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

1.10.0 · 2026-07-13 · UTF-8 · 526 API signatures

문서 개요

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

실행 파이프라인lexer → parser/AST → strict typecheck → register bytecode → register VM. Windows x64의 --jit는 지원 함수·메서드를 warm-up 뒤 부분 컴파일합니다.

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

검증 기준최종 1.10.0 engine에서 core suite는 VM 70/70과 JIT 70/70을 통과했습니다.

Sura source 확장자는 .sura입니다. 값은 NaN-boxed dynamic Value로 표현하고, register VM과 mark-sweep GC가 실행합니다. GC heap은 프로세스 전역입니다.

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

설치와 실행

Windows x64 공개 파일

파일	용도
SuraLanguageSetup-1.10.0.exe	단일 설치 파일
SuraLanguage-1.10.0-windows-x64.zip	설치 kit와 payload 검증
SuraLanguage-VSCode-1.10.0.vsix	VS Code 언어 확장

설치기는 Windows x64, .NET Framework CLR, Windows PowerShell 또는 PowerShell을 사용합니다. 설치된 runtime은 %LOCALAPPDATA%\Programs\Sura\bin에 위치하고 sura와 surapkg 명령을 만듭니다.

sura --version
sura app.sura
sura --jit app.sura
sura --repl
surapkg init my_app

소스 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 \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.10.0의 기본 검사는 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이 한쪽에 있으면 `+`가 다른 값을 문자열로 변환; VM은 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입니다. VM의 array + array는 연결을 수행하며 strict checker는 알려진 array 두 개의 +에 E201을 보고합니다.

비트 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.10.0 출력입니다.

Sura Language Runtime 1.10.0
Usage:
  sura --version             Show the Sura Language version
  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 --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 (x86-64)
  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개·526 signature이며, console이 별도 runtime module입니다. global builtin registry에는 case-sensitive 직접 호출 이름과 alias 662개가 있습니다.

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 연산과 optimizer62 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])`
`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 tokenizer와 tokenizer 파일6 signatures

이름	호출 서명
`byte`	`tokenizer.byte([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

662개 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_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 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, uint32 shard, seek 기반 batch loader
weight 교환	Safetensors read/write, PyTorch bridge through Safetensors, ONNX initializer read/write
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. 현재 미구현 범위: general broadcasting, batched-right matmul, dense softmax/cross-entropy, low activation/output, mixed backward 가속, FlashAttention, KV cache, AdamW, NCCL, ONNX graph execution, BPE, 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
clip is media.ascii_frames("clip.mp4", {
  width: 80,
  fps: 8,
  max_frames: 300,
  charset: " .:-=+*#%@",
  dither: true
})
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을 제외합니다.

도구	기능
`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
`--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

surapkg CLI 전체 목록

Sura package manager
Usage:
  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-13 AST lowering 분류
Native VM/JIT	주 실행 경로; dynamic Value runtime 전체 사용
JavaScript	43개 node 중 full 41, ignored 2, partial 0
WebAssembly	43개 node 중 full 28, partial 13, ignored 2

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 13개 node가 partial 상태입니다. 전체 audit status는 INCOMPLETE입니다.

빌드와 배포

출력	내용
`.sura.bc`	`--compile`이 만드는 SURB v3 register bytecode; 1.10.0 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	70/70 PASS; 70/70 PASS
bytecode validation	19/19 PASS; 3 accepted fixtures and 16 rejection cases
JIT safety	native frame boundary·Win64 unwind·uncaught upvalue cleanup·native exception no-replay PASS
FFI safety	GC isolation, token/lease concurrency, run-bound value quarantine PASS
async runtime concurrency	2/2 rounds PASS; 10 cases per round; 50000 queued cancellations completed in 40 ms and 42 ms
release payload	engine and surapkg hashes match in final ZIP and final single-file installer

검증 파일의 2cba8070938783da9622a7f01a80d1a2b78aa21bef6d3142ee21303478dc08c0 해시는 SuraLanguage.exe 8438343 bytes를 식별합니다. 같은 바이트를 저장소 빌드, 단일 설치 파일 payload, Windows x64 ZIP payload에서 확인했습니다. surapkg.exe는 5347656 bytes, SHA-256 ba8c26cddc44e935fe61e073c3a6cd6040b816b6a274b48ced135c9beb452fe8입니다.

2026-07-13 Windows x64 portable O3 build, 12th Gen Intel(R) Core(TM) i5-12400F, g++.exe (Rev13, Built by MSYS2 project) 15.2.0에서 100,000-step 동일 inner-loop 30회 측정은 Vec2 Sura JIT 1.935 ms, C++ O3 0.050 ms, 비율 38.33×였습니다. Vec3는 Sura JIT 5.297 ms, C++ O3 0.050 ms, 비율 105.62×였습니다. 목표 10× 이내는 달성하지 못했습니다. 측정 engine SHA-256은 2cba8070938783da9622a7f01a80d1a2b78aa21bef6d3142ee21303478dc08c0입니다.

직전 2026-07-12 측정은 Vec2 17.225 ms, Vec3 62.254 ms였습니다. workload와 장비는 같지만 새 측정은 현재 portable binary 30회 기록입니다.

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 ABI만 구현하며, 다른 플랫폼이나 ABI에서는 native compilation을 거절하고 register VM에서 실행합니다. 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, runtime contract, 기본값 평가, syntax, truthiness, stdlib catalog, 34개 module의 526개 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.10.0",
  "published_date": "2026-07-13",
  "source_extension": ".sura",
  "package_manifest": "sura.pkg.json",
  "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",
      "emitter_backend": "Win64 x64 only; other platforms and ABIs remain in the register VM",
      "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",
    "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, \\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": 526,
    "global_builtin_name_and_alias_count": 662,
    "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_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",
      "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": 62,
        "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": "all_reduce_gradients",
            "signature": "autograd.all_reduce_gradients(parameters, options)",
            "source": "builtin:autograd",
            "line": 62
          }
        ],
        "description": "typed Tensor, reverse-mode 자동미분, CPU/CUDA 연산과 optimizer",
        "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": 6,
        "symbols": [
          {
            "kind": "function",
            "name": "byte",
            "signature": "tokenizer.byte([options])",
            "source": "builtin:tokenizer",
            "line": 1
          },
          {
            "kind": "function",
            "name": "encode",
            "signature": "tokenizer.encode(tokenizer, text, [options])",
            "source": "builtin:tokenizer",
            "line": 2
          },
          {
            "kind": "function",
            "name": "decode",
            "signature": "tokenizer.decode(tokenizer, ids, [options])",
            "source": "builtin:tokenizer",
            "line": 3
          },
          {
            "kind": "function",
            "name": "info",
            "signature": "tokenizer.info(tokenizer)",
            "source": "builtin:tokenizer",
            "line": 4
          },
          {
            "kind": "function",
            "name": "save",
            "signature": "tokenizer.save(tokenizer, path)",
            "source": "builtin:tokenizer",
            "line": 5
          },
          {
            "kind": "function",
            "name": "load",
            "signature": "tokenizer.load(path)",
            "source": "builtin:tokenizer",
            "line": 6
          }
        ],
        "description": "UTF-8 raw-byte 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"
  },
  "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": 28,
      "ignored": 2,
      "partial": 13,
      "classification_complete": false,
      "runtime_parity_with_native": false
    }
  },
  "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.10.0.json",
    "schema": "sura.public.verification.v1",
    "product": "Sura Language",
    "version": "1.10.0",
    "verified": "2026-07-13",
    "engine_file": "SuraLanguage.exe",
    "engine_sha256": "2cba8070938783da9622a7f01a80d1a2b78aa21bef6d3142ee21303478dc08c0",
    "engine_bytes": 8438343,
    "engine_locations_checked": [
      "repository build",
      "SuraLanguageSetup-1.10.0.exe payload",
      "SuraLanguage-1.10.0-windows-x64.zip payload"
    ],
    "package_helper": {
      "file": "surapkg.exe",
      "bytes": 5347656,
      "sha256": "ba8c26cddc44e935fe61e073c3a6cd6040b816b6a274b48ced135c9beb452fe8"
    },
    "results": {
      "core_vm": "70/70 PASS",
      "core_jit": "70/70 PASS",
      "bytecode_validation": "19/19 PASS; 3 accepted fixtures and 16 rejection cases",
      "jit_native_frame_boundary": "PASS",
      "jit_unwind_registration": "PASS",
      "jit_uncaught_upvalue_cleanup": "PASS",
      "jit_native_exception_no_replay": "PASS",
      "ffi_abi": "1.2.0",
      "ffi_safety": "GC isolation, token/lease concurrency, run-bound value quarantine PASS",
      "async_runtime_concurrency": "2/2 rounds PASS; 10 cases per round; 50000 queued cancellations completed in 40 ms and 42 ms",
      "target_lowering_audit": "INCOMPLETE; JS full 41 ignored 2; WASM full 28 partial 13 ignored 2",
      "installer_smoke": "PASS",
      "release_payload_identity": "engine and surapkg hashes match in final ZIP and final single-file installer",
      "vscode_extension": "compile, smoke, esbuild, and VSIX package PASS"
    },
    "performance_record": {
      "source": "artifacts/native_perf.json",
      "sha256": "4fc519f0473bcb5265214ef43abe01617343bc8f86e922a18a9c1a8f1e9c34ea",
      "generated_utc": "2026-07-13T04:48:16Z",
      "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
    }
  },
  "release": {
    "schema": "sura.public.release.v1",
    "product": "Sura Language",
    "version": "1.10.0",
    "published": "2026-07-13",
    "platform": "windows-x64",
    "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.10.0.exe",
        "bytes": 23366656,
        "sha256": "5b13f37f4b49764eb24a61d0d5a2fe90c8f023e620868f931c20a9080e91bc8d"
      },
      {
        "name": "SuraLanguage-1.10.0-windows-x64.zip",
        "bytes": 8020953,
        "sha256": "5b84f6a4d5a4c48e24159705bd0846d0814be16f90f1273dd8d78436b5a3343e"
      },
      {
        "name": "SuraLanguage-VSCode-1.10.0.vsix",
        "bytes": 58304,
        "sha256": "2bb6028bc0f64115ee549716b60bbc5bbc8978e0a3d001b899066e4d11a2a474"
      }
    ]
  },
  "performance_records": {
    "native_baseline_current": {
      "source": "/downloads/verification-1.10.0.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": [
      "native emitter backends beyond Win64 x64",
      "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": "526 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": "662 case-sensitive direct-call names and aliases are enumerated"
  },
  "cli_help": "Sura Language Runtime 1.10.0\r\nUsage:\r\n  sura --version             Show the Sura Language version\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 --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 (x86-64)\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 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"
}