## Command Reference
See the [changelog](https://github.com/jzombie/rust-oxdock/blob/main/CHANGELOG.md) for what changed in each release.
| [`WORKDIR`](#workdir) | `WORKDIR <path>` |
| [`WORKSPACE`](#workspace) | `WORKSPACE (SNAPSHOT\|LOCAL, case-insensitive)` |
| [`ENV`](#env) | `ENV KEY=value` |
| [`INHERIT_ENV`](#inherit_env) | `INHERIT_ENV [<key>, ...]` |
| [`ECHO`](#echo) | `ECHO <message>` |
| [`RUN`](#run) | `RUN <command...> \| RUN ["exe", "arg", ...]` |
| [`COPY`](#copy) | `COPY [--from-current-workspace] <from> <to>` |
| [`COPY_GIT`](#copy_git) | `COPY_GIT [--include-dirty] <rev> <src> <dst>` |
| [`SYMLINK`](#symlink) | `SYMLINK <from> <to>` |
| [`MKDIR`](#mkdir) | `MKDIR <path>` |
| [`LS`](#ls) | `LS [<path>]` |
| [`CWD`](#cwd) | `CWD` |
| [`READ`](#read) | `READ [<path>]` |
| [`READ_LINE`](#read_line) | `READ_LINE $var` |
| [`WRITE`](#write) | `WRITE <path> [<contents>]` |
| [`APPEND`](#append) | `APPEND <path> [<contents>]` |
| [`EXPAND`](#expand) | `EXPAND [<path>] [<KEY=val> ...]` |
| [`ASSERT_EQ`](#assert_eq) | `ASSERT_EQ <actual> <expected> \| ASSERT_EQ --hash <sha256> <actual>` |
| [`ASSERT_CONTAINS`](#assert_contains) | `ASSERT_CONTAINS <haystack> <needle>` |
| [`HASH_SHA256`](#hash_sha256) | `HASH_SHA256 <path>` |
| [`EXIT`](#exit) | `EXIT <code>` |
| [`SLEEP`](#sleep) | `SLEEP <duration>` |
| [`LIST_APPEND`](#list_append) | `LIST_APPEND $list <item>` |
| [`WITH_IO`](#with_io) | `WITH_IO [<stream>[=$var], ...] <command> \| WITH_IO [bindings] { <commands> }` |
| [`FOR`](#for) | `FOR $item: TYPE IN <expr> { <commands> } \| FOR $key: STRING, $value: TYPE IN <expr> { <commands> }` |
| [`IF`](#if) | `IF <expr> { <commands> } [ELSE IF <expr> { <commands> } ...] [ELSE { <commands> }]` |
| [`LET`](#let) | `LET $var: TYPE = <expr> \| LET $p: PIPE \| LET $var: TYPE = ASYNC { <commands> } \| LET $var: TYPE = <command> \| LET $var: TYPE = AWAIT $task \| LET $var: TYPE = { <commands> }` |
| [`MUTATION`](#mutation) | `$var = <expr>` |
| [`ASYNC`](#async) | `ASYNC <command...> \| ASYNC { <commands> } \| LET $var: HANDLE = ASYNC { <commands> }` |
| [`AWAIT`](#await) | `AWAIT $var \| LET $out: STRING = AWAIT $var` |
| [`CANCEL`](#cancel) | `CANCEL $var` |
| [`TIMEOUT`](#timeout) | `TIMEOUT <duration> <command...> \| TIMEOUT <duration> { <commands> } \| TIMEOUT <duration> AWAIT $var` |
| [`FUNC`](#func) | `FUNC NAME([$param: TYPE, ...]) { <commands> }` |
| [`RETURN`](#return) | `RETURN [<expr>]` |
| [`WHILE`](#while) | `WHILE <bool-expr> { <commands> }` |
| [`BREAK`](#break) | `BREAK` |
| [`CONTINUE`](#continue) | `CONTINUE` |
| [`IMPORT`](#import) | `IMPORT [<module>, ...] \| IMPORT <module>` |
### WITH_IO
Reroute standard streams.
**Syntax:** `WITH_IO [<stream>[=$var], ...] <command> | WITH_IO [bindings] { <commands> }`
Reroutes the standard streams of the next command or, in block form,
of every enclosed command.
Bindings map streams (`stdin`, `stdout`, `stderr`) to a PIPE-typed
variable (`stdout=$p`, `stdin=$p`), resolved from the variable
when the step runs. Both stdout and stderr pipes capture output
the same way. Declare the handle first with `LET $p: PIPE`.
Pipes hold bytes in memory and spill to a temp file above 8 MiB, so a
producer can finish before the consumer starts.
If WITH_IO wraps an ASYNC block whose body is a single RUN, guarded or
not, the pipe is a zero copy OS kernel pipe instead: pair it with a
consumer that runs while the producer is alive, since output past the
64 KiB kernel buffer stalls until drained. That promotion never crosses
a function boundary: pipes created, bound, or passed by variable inside FUNC
bodies are always script pipes, even when the surrounding task would
otherwise promote.
A second producer or consumer on a live handle is an explicit
error. A handle bound as output can later feed another
command's `stdin`, connecting commands without touching the
terminal. Binding `stdout` and `stderr` to the same live
handle fails deterministically. Merge streams in shell
via `2>&1` instead.
Nested blocks stack defaults; inline bindings override inherited ones for
their command only; closing a block restores previous wiring.
**Examples:**
**Example: with_io block**
```oxdock
LET $log: PIPE
WITH_IO [stdout=$log] {
ECHO first
ECHO second
}
WITH_IO [stdin=$log] WRITE captured.txt
```
**Example: variable pipe binding**
```oxdock
# Declare the pipe first: `LET $p: PIPE` mints a fresh
# backend without touching a stream. A plain string here
# would be a TypeMismatch.
LET $p: PIPE
WITH_IO [stdout=$p] ECHO hello
WITH_IO [stdin=$p] READ_LINE $line
ASSERT_EQ $line "hello"
```
### FOR
Iterate over a list or map.
**Syntax:** `FOR $item: TYPE IN <expr> { <commands> } | FOR $key: STRING, $value: TYPE IN <expr> { <commands> }`
The loop variable receives each element (lists) or value (maps); with
two variables, the first receives the key.
Loop variables are declared with explicit types and scoped per iteration;
they do not leak outward. The body may be a braced block
or a single-line `{ ... }` command.
`GLOB("...")` patterns must be quoted (`*` is not a bare word, so
`GLOB(*)` is a parse error); GLOB returns a root-relative sorted list,
empty when nothing matches, and rejects `..` escapes.
**Examples:**
**Example: for loop**
```oxdock
LET $items: LIST = ["a", "b"]
FOR $item: STRING IN $items {
ECHO $item
}
LET $map: MAP = {"x": 1}
FOR $k: STRING, $v: INT IN $map {
ECHO "$k=$v"
}
```
**Example: expand every match**
```oxdock
# single-line body; $x is a template path, WHO an override
WRITE a.txt "hi \{{ env:WHO }}!"
IMPORT [STD]
FOR $x: STRING IN GLOB("*.txt") { EXPAND $x WHO=World }
ASSERT_CONTAINS stdout "hi World!"
```
### IF
Conditional execution.
**Syntax:** `IF <expr> { <commands> } [ELSE IF <expr> { <commands> } ...] [ELSE { <commands> }]`
The condition is evaluated as a boolean expression.
Prefix `!` negates (`IF !false`); `&&` binds tighter than
`||`, and both short-circuit, so `IF true || $missing`
never evaluates the right side. Only Bool values are
accepted as conditions.
**Examples:**
**Example: if else**
```oxdock
IMPORT [STD]
IF true {
WRITE yes.txt taken
} ELSE {
WRITE yes.txt skipped
}
IF false {
WRITE skipped.txt no
} ELSE IF true {
WRITE fallback.txt taken
}
# !false evaluates to true, so this branch runs.
IF !false {
WRITE negated.txt taken
}
LET $yes_body: STRING = READ yes.txt
LET $fallback_body: STRING = READ fallback.txt
LET $negated_body: STRING = READ negated.txt
ASSERT_EQ $yes_body "taken"
ASSERT_EQ $fallback_body "taken"
ASSERT_EQ $negated_body "taken"
LET $t: STRING = PATH_TYPE("skipped.txt")
ASSERT_EQ $t "absent"
```
**Example: logical condition composition**
```oxdock
IMPORT [STD]
LET $role: STRING = "admin"
LET $level: INT = 3
# || is true when either side holds; && needs both.
} ELSE {
WRITE fallback.txt or-false
}
}
IF $role == "admin" && $level >= 5 {
WRITE unexpected-too.txt no
} ELSE {
WRITE and.txt and-false
}
LET $fb: STRING = READ fallback.txt
LET $ch: STRING = READ chosen.txt
LET $an: STRING = READ and.txt
ASSERT_EQ $fb "or-false"
ASSERT_EQ $ch "or-true"
ASSERT_EQ $an "and-false"
LET $t1: STRING = PATH_TYPE("unexpected.txt")
LET $t2: STRING = PATH_TYPE("unexpected-too.txt")
ASSERT_EQ $t1 "absent"
ASSERT_EQ $t2 "absent"
```
### LET
Bind script-local variables.
**Syntax:** `LET $var: TYPE = <expr> | LET $p: PIPE | LET $var: TYPE = ASYNC { <commands> } | LET $var: TYPE = <command> | LET $var: TYPE = AWAIT $task | LET $var: TYPE = { <commands> }`
Declares a script-local variable with an explicit type (STRING, INT,
FLOAT, BOOL, PIPE, LIST, MAP, HANDLE, DURATION, PATH). Duplicate LET
in the same scope frame is a redeclaration error; mutate with
`$var = <expr>`.
Variables are usable in templates (`{{ $var }}`), guards, and
expressions. With `ASYNC`, spawns a background task and stores its
handle (see ASYNC). The `$` sigil on the name is mandatory.
No hoisting: a variable exists only after its LET runs, in
execution order. Reading `$var` before its LET (or after the
block that declared it exits) fails with
`undefined variable $var`. Scopes are a stack of frames and
resolution walks innermost outward, so nothing pre-declares
names. Function bodies read outer variables through the same
walk, but their own LETs never leak out (see FUNC).
The right-hand side is always an expression — literals, lists, maps,
arithmetic (`+ - * /` with `*`/`/` binding tighter, unary `-`,
parentheses), comparisons (`< <= > >=` binding tighter than
`== !=`), logical `&&` (tighter) and `||` with short-circuit,
`!` negation, `env:KEY` reads, `INSPECT($var)` snapshots,
`GLOB("*.md")`, `INT(x)` / `FLOAT(x)` conversions — never a
`{{ ... }}` template; interpolation happens in string values,
not here.
The one exception is pipes: `LET $p: PIPE` with no `=`
and no initializer mints a fresh anonymous backend,
lazily materialized at first binding, so two declarations
never share a channel.
Numbers are numeric literals: `42` binds `INT`, `3.14` binds
`FLOAT`. `Int x Int` stays `INT` (checked, integer division,
so `7 / 2` is `3`); any `Float` operand promotes to `FLOAT`.
Division by zero, overflow, and non-finite results are errors.
Both numeric sides compare numerically (`1 == 1.0` is true);
otherwise `==`/`!=` compare rendered strings and ordering on
non-numerics is a Type Error. Constant subtrees fold at parse
time and dynamic arithmetic compiles to flat RPN with
identical semantics.
Float equality is exact with no epsilon. Floats store decimals
in binary, so a value is exact only when its reduced fraction
has a power-of-2 denominator: 0.5 (1/2), 0.25 (1/4), 0.75
(3/4) are exact, while 0.1 (1/10), 0.2 (1/5), 0.3 (3/10)
repeat forever in binary (like 1/3 in decimal) and truncate,
so `0.1 + 0.2 == 0.3` is false (the sum is
`0.30000000000000004`). Rule of thumb: endings .5, .25, .75,
.125, .625, .875 are exact; .1, .2, .3 and similar are
approximations. Bound approximations instead of comparing
them: `IF $sum > 0.299999 && $sum < 0.300001`.
Comparisons do not chain: `a < b < c` is a parse error, not
`(a < b) < c`. Chaining would compare a `BOOL` against a
number (a runtime Type Error in C-style parsing) or evaluate
the middle term twice (Python-style chaining), so the grammar
accepts exactly one comparison operator per level. Write the
conjunction explicitly: `$a < $b && $b < $c`. The same holds
for equality (`$a == $b == $c` is rejected).
Captured command output is a string, so convert before math:
`LET $total: INT = $total + INT($size_str)` (`INT` trims ASCII
whitespace; `FLOAT` accepts int strings and rejects
non-finite).
Bare words need no quotes: `LET $d: STRING = 30s` binds the same string
as quoted.
When the right-hand side is a synchronous command
(`LET $out: STRING = ECHO hi`), the command runs to completion and its
exact stdout bytes are captured into the variable as a string (no newline
stripping; commands with no stdout capture as `""`; non-UTF8 stdout is
an error). Combining capture with an explicit
`WITH_IO [stdout=$var]` is a parse error.
Coming from Bash, the capture line looks familiar but behaves
strictly:
| Trailing newlines | Stripped (all of them) | Preserved byte-exact |
| Variable type | Always an untyped string | Declared: STRING, INT, FLOAT, ... |
| Math on output | Implicit: `$((var + 1))` | Explicit: `INT($out) + 1` |
| Failing command | Continues with empty output unless `set -e` | Step fails immediately, binds nothing |
`LET $out: TYPE = AWAIT $var` binds the background task's
explicit `RETURN` value instead (tasks stream their stdout
live, so there is no output left to capture); a task that
succeeded without `RETURN` yields `INT` 0, like a process
exit status.
An inline block (`LET $var: TYPE = { <commands> }`) runs its
steps in a fresh scope and binds the nearest `RETURN` value,
like a zero-arg function body: fallthrough without `RETURN`
binds `""`, and `BREAK`/`CONTINUE` escaping the block are
errors. The block reads outer variables but its own LETs
never leak out. A `{k: v}` shape still parses as a map
literal; anything else in braces is a block.
The split is deliberate: synchronous commands capture
stdout because they run inline to completion on the same
thread; background tasks never capture stdout because
concurrent output has no well-defined value. Task results
travel only through `RETURN` (or `INT` 0 for void tasks).
`LET $e: STRING = env:FOO` reads the script environment into a plain
string.
**Examples:**
**Example: let**
```oxdock
LET $name: STRING = "world"
ECHO "hello, {{ $name }}"
LET $items: LIST = ["a", "b"]
LET $count: INT = 42
```
**Example: no hoisting**
```oxdock expect_error:"undefined variable"
# reading before the LET runs is an error, not an empty value
ECHO $too_early
LET $too_early: STRING = "too late"
```
**Expected error:** `undefined variable`
**Example: glob binding**
```oxdock
# the RHS is an expression: GLOB(...) runs and binds a list
WRITE a.txt "x"
IMPORT [STD]
LET $files: LIST = GLOB("*.txt")
FOR $f: STRING IN $files { ECHO $f }
ASSERT_CONTAINS stdout "a.txt"
```
**Example: scoped variable reverts**
```oxdock
# LET inside a braced block reverts when the block exits
LET $a: STRING = "outer"
[bool:true] {
LET $a: STRING = "inner"
WRITE inner.txt "{{ $a }}"
}
WRITE outer.txt "{{ $a }}"
LET $in_body: STRING = READ inner.txt
LET $out_body: STRING = READ outer.txt
ASSERT_EQ $in_body "inner"
ASSERT_EQ $out_body "outer"
```
**Example: capture command output**
```oxdock
LET $out: STRING = ECHO hi
ASSERT_EQ $out "hi\n"
```
**Example: inline block**
```oxdock
LET $who: STRING = "ada"
LET $res: STRING = {
LET $loud: STRING = "{{ $who }}!"
RETURN $loud
}
ASSERT_EQ $res "ada!"
# Any declared type works: the block value checks like any RHS.
LET $n: INT = {
RETURN 40 + 2
}
ASSERT_EQ $n 42
```
**Example: arithmetic over captured output**
```oxdock
LET $size_str: STRING = ECHO 41
IMPORT [STD]
LET $total: INT = INT($size_str) + 1
LET $ratio: FLOAT = 1 + 2.5
# Int x Int stays INT: integer division truncates.
LET $half: INT = 7 / 2
ASSERT_EQ $total 42
ASSERT_EQ $ratio 3.5
ASSERT_EQ $half 3
```
**Example: float equality is exact**
```oxdock
# Binary fractions compare cleanly; decimal fractions may not:
# 0.1 + 0.2 is 0.30000000000000004, so == is false.
IMPORT [STD]
LET $exact: BOOL = 0.5 + 0.25 == 0.75
LET $decimal: BOOL = 0.1 + 0.2 == 0.3
IF $exact {
WRITE exact.txt yes
}
IF $decimal {
WRITE unexpected.txt no
}
LET $ok: STRING = READ exact.txt
ASSERT_EQ $ok "yes"
LET $t: STRING = PATH_TYPE("unexpected.txt")
ASSERT_EQ $t "absent"
```
**Example: bound inexact decimals**
```oxdock
# Never test inexact decimals for equality; bound them.
LET $sum: FLOAT = 0.1 + 0.2
IF $sum > 0.299999 && $sum < 0.300001 {
WRITE bounded.txt yes
}
LET $ok: STRING = READ bounded.txt
ASSERT_EQ $ok "yes"
```
**Example: inspect a variable**
```oxdock
# INSPECT($var) snapshots a variable into a MAP: declared
# type plus live details (pipe backend stats here), so
# scripts can branch on engine state.
LET $p: PIPE
WITH_IO [stdout=$p] ECHO hello
LET $info: MAP = INSPECT($p)
IF $info.is_os_pipe {
WRITE unexpected.txt "should be a script pipe"
}
ASSERT_EQ $info.type "PIPE"
```
### MUTATION
Mutate a declared variable.
**Syntax:** `$var = <expr>`
Reassigns an existing variable, converting the new value to
the type declared at LET time. The explicit annotation is
what authorizes string-to-number conversion here (`$n = "42"`
binds 42 for an INT); a non-numeric string is an error.
Expressions never convert: `"100" + 1` is a Type Error, use
`INT()` / `FLOAT()` to cross that boundary explicitly.
The leading `$` distinguishes mutation from `KEY=value` command
assignments. Assigning an undeclared variable or a mismatched type is
an error.
Mutation writes through to the scope where the variable was
declared, so it survives block exit: `LET $x` outside a block
followed by `$x = ...` inside still reads back the new value
afterwards, for every type. This is the counterpart to LET
shadowing, where `LET $x` *inside* the block declares a
separate inner variable that reverts on exit.
**Examples:**
**Example: mutate**
```oxdock
LET $count: INT = 1
$count = 2
ASSERT_EQ $count 2
```
**Example: convert before math**
```oxdock
# Captured output is a string: `"100" + 1` is a Type Error.
# Convert explicitly, then mutate with arithmetic.
LET $raw: STRING = ECHO 100
IMPORT [STD]
LET $n: INT = INT($raw)
$n = $n + 1
# The declared type also converts plain strings on assignment.
$n = "42"
# Same crossing for decimals via FLOAT().
LET $frac_str: STRING = ECHO 2.5
LET $f: FLOAT = FLOAT($frac_str) + 0.25
ASSERT_EQ $n 42
ASSERT_EQ $f 2.75
```
### ASYNC
Run steps in a background thread.
**Syntax:** `ASYNC <command...> | ASYNC { <commands> } | LET $var: HANDLE = ASYNC { <commands> }`
Runs a command or block of commands in a background thread with
subshell isolation.
Mutations (ENV, WORKDIR) stay within the block. With `LET`, stores a
task handle for `AWAIT`. Task output streams live to the parent
stdout; a task publishes a value with an explicit `RETURN`,
which `LET $out: TYPE = AWAIT $task` binds.
**Examples:**
**Example: async**
```oxdock
ASYNC ECHO "first"
ASYNC {
ECHO "first"
ECHO "second"
}
```
**Example: async task handle**
```oxdock
LET $task: HANDLE = ASYNC {
ECHO "built"
}
AWAIT $task
```
### AWAIT
Join a background task.
**Syntax:** `AWAIT $var | LET $out: STRING = AWAIT $var`
Blocks until the named task completes. Propagates errors if the task failed.
Task output streams live during the run; joining binds nothing by
itself. `LET $out: TYPE = AWAIT $var` binds the task's explicit
`RETURN` value instead, or `INT` 0 when the task succeeded
without one (add `RETURN <expr>` to the task body to yield
a value).
**Examples:**
**Example: await**
```oxdock
LET $task: HANDLE = ASYNC ECHO "done"
AWAIT $task
```
**Example: await capture**
```oxdock
LET $task: HANDLE = ASYNC {
ECHO "logged"
RETURN "returned"
}
LET $out: STRING = AWAIT $task
ASSERT_EQ $out "returned"
```
### CANCEL
Synchronously cancel a background task.
**Syntax:** `CANCEL $var`
Kills the named background task spawned via LET $var: HANDLE = ASYNC ....
Blocking: returns only after the task thread has been joined and its OS
process reaped, so no residual filesystem or stream mutation follows. A
later AWAIT $var reports cancellation. Only named tasks can be cancelled.
**Examples:**
**Example: cancel**
```oxdock
LET $task: HANDLE = ASYNC SLEEP 30s
CANCEL $task
```
### TIMEOUT
Enforce an execution deadline.
**Syntax:** `TIMEOUT <duration> <command...> | TIMEOUT <duration> { <commands> } | TIMEOUT <duration> AWAIT $var`
Aborts the wrapped step or block with a deadline error if it exceeds the
duration (e.g. 500ms, 10s, 2m; a bare number means seconds).
A blocking foreground process is killed.
**Examples:**
**Example: timeout**
```oxdock
TIMEOUT 30s WRITE heartbeat.txt alive
```
**Example: timeout block**
```oxdock
TIMEOUT 30s {
WRITE a.txt one
WRITE b.txt two
}
```
**Example: timeout variable duration**
```oxdock
# durations resolve at runtime, so variables work too
LET $budget: DURATION = "30s"
TIMEOUT $budget WRITE heartbeat.txt alive
LET $beat: STRING = READ heartbeat.txt
ASSERT_EQ $beat "alive"
```
### FUNC
Define a user function.
**Syntax:** `FUNC NAME([$param: TYPE, ...]) { <commands> }`
Defines a user function with UPPERCASE name and explicitly typed
parameters.
Params bind by position, converting each argument to its
declared parameter type before the body runs.
Bodies run in a fresh variable scope; LETs inside do not leak. A nested
FUNC definition is scoped to its block and reverts on exit. Names share
one namespace with native and host-registered functions, which a FUNC
may never shadow.
Functions resolve like variables: a name is visible from its
definition line, so recursion works but mutual recursion does
not (the second name does not exist while the first body
lowers). Calls name their module (`STD::GLOB(...)`) unless
imported; see IMPORT.
Invoke any function with one syntax: `NAME(...)` as a statement
(discarding the value) or `LET $var: TYPE = NAME(...)` to capture
the RETURN value (fallthrough without RETURN captures as "").
**Examples:**
**Example: func def call**
```oxdock
FUNC GREET($name: STRING) {
RETURN $name
}
LET $res: STRING = GREET("ada")
ASSERT_EQ $res "ada"
# Statement form: parens stay, the value drops.
GREET("bex")
```
**Example: call with pipes**
```oxdock
# A pipe handle travels into a function as a typed argument
# and is usable as a binding target in both directions.
# `LET $p: PIPE` mints the handle; `$p` passes it on.
FUNC DRAIN($q: PIPE) {
WITH_IO [stdin=$q] READ_LINE $line
RETURN $line
}
LET $p: PIPE
WITH_IO [stdout=$p] ECHO "payload"
LET $got: STRING = DRAIN($p)
ASSERT_EQ $got "payload"
```
### RETURN
Return a value from a function, task, or inline block.
**Syntax:** `RETURN [<expr>]`
Ends the nearest enclosing boundary with a value: a function
call, an `ASYNC` task (bound by `LET $o = AWAIT $t`), or an
inline `LET` block. Bare `RETURN` with no expression yields
`""`.
Falling off the end without RETURN yields "". RETURN with no
enclosing boundary (including at top level) is an error; use
EXIT or ECHO there.
**Examples:**
**Example: return**
```oxdock
FUNC PICK($flag: BOOL) {
IF $flag {
RETURN "yes"
}
RETURN "no"
}
LET $res: STRING = PICK(true)
ASSERT_EQ $res "yes"
```
### WHILE
Loop while a condition holds.
**Syntax:** `WHILE <bool-expr> { <commands> }`
Re-evaluates a Bool condition each iteration (same is_truthy rule as IF;
non-Bool is a type error).
Each iteration runs in a fresh scope; mutate outer state with $var = ...
so the next check observes it. BREAK exits the loop; CONTINUE skips to
the next check.
**Examples:**
**Example: while loop**
```oxdock
LET $done: BOOL = false
WHILE !$done {
WRITE tick.txt "once"
$done = true
}
LET $tick: STRING = READ tick.txt
ASSERT_EQ $tick "once"
```
### BREAK
Exit the innermost loop.
**Syntax:** `BREAK`
Exits the innermost enclosing FOR or WHILE loop.
BREAK outside a loop, or across a FUNC or ASYNC boundary, is an error.
**Examples:**
**Example: break**
```oxdock
FOR $x: STRING IN ["a", "b"] {
BREAK
}
```
### CONTINUE
Skip to the next loop iteration.
**Syntax:** `CONTINUE`
Skips the rest of the innermost enclosing FOR or WHILE body and starts
the next iteration.
CONTINUE outside a loop, or across a FUNC or ASYNC boundary, is an error.
**Examples:**
**Example: continue**
```oxdock
FOR $x: STRING IN ["a", "b"] {
CONTINUE
}
```
### IMPORT
Bring module functions into bare-call scope.
**Syntax:** `IMPORT [<module>, ...] | IMPORT <module>`
Every function call names its module (`STD::GLOB(...)`,
`MOCK::READ_CSV(...)`) unless the module is imported:
`IMPORT [STD]` lets the rest of the scope call `GLOB(...)`
bare. Calls resolve at parse time against `SCRIPT`
definitions first, then imported modules; unknown modules,
unknown functions, and unimported bare calls are parse
errors, never runtime surprises.
IMPORT is a lowering directive, not a step: it applies from
its line to the enclosing block exit, then reverts, exactly
like `LET` scoping but with no runtime footprint. Guards do
not apply to it. Two imported modules exporting one name is
an ambiguity error: qualify the call instead.
`EXPORT` is reserved for future script-module support and
cannot be used yet.
**Examples:**
**Example: import**
```oxdock
WRITE a.txt "hi \{{ env:WHO }}!"
IMPORT [STD]
FOR $x: STRING IN GLOB("*.txt") { EXPAND $x WHO=World }
ASSERT_CONTAINS stdout "hi World!"
```
### WORKDIR
Change the working directory.
**Syntax:** `WORKDIR <path>`
Sets the current working directory.
Relative paths resolve against the current directory; `/` resets to
the workspace root. Paths cannot escape the workspace.
**Arguments:**
| `path` | [`PATH`](#value-type-path) | yes | Directory to change to |
**Examples:**
**Example: change working directory**
```oxdock
WORKDIR project/src
WRITE generated.txt generated-under-workdir
LET $body: STRING = READ generated.txt
ASSERT_EQ $body "generated-under-workdir"
```
### WORKSPACE
Switch workspace roots.
**Syntax:** `WORKSPACE (SNAPSHOT|LOCAL, case-insensitive)`
SNAPSHOT or LOCAL root.
**Arguments:**
| `target` | `SNAPSHOT\|LOCAL` | yes | Target root |
**Examples:**
**Example: switch roots**
```oxdock
WORKSPACE LOCAL
```
### ENV
Set an environment variable.
**Syntax:** `ENV KEY=value`
Inserts or updates an env var.
The value uses the unified string-value rules shared by every command:
`"..."` or `'...'` quotes keep exact bytes (spaces, tabs), a lone `$var`
evaluates that variable, `{{ ... }}` placeholders interpolate, unquoted
words join with single spaces, and the first `=` splits key from value
(`KEY=a=b` stores `a=b`).
A `$var` inside larger text stays literal — write `{{ $var }}` to
interpolate there.
**Arguments:**
| `assignment` | [`STRING`](#value-type-string) | yes | KEY=value pair; the value resolves as STRING |
**Examples:**
**Example: set env**
```oxdock
ENV APP_MODE=production
```
**Example: quoted value with spaces**
```oxdock
# quotes keep the space: SET_FORTH stores `outer scope`
ENV SET_FORTH="outer scope"
WRITE out.txt "{{ env:SET_FORTH }}"
LET $body: STRING = READ out.txt
ASSERT_EQ $body "outer scope"
```
**Example: variable value**
```oxdock
# a lone $var evaluates, like ECHO $var
LET $who: STRING = "Alice"
ENV GREETING=$who
WRITE out.txt "{{ env:GREETING }}"
LET $body: STRING = READ out.txt
ASSERT_EQ $body "Alice"
```
**Example: all value forms agree**
```oxdock
# a bare variable, a quoted literal, and a template all
# store plain strings through the same value rules
LET $x: STRING = "Ada"
ENV A=$x
ENV B="hello world"
ENV C="{{ $x }} concatenated"
ASSERT_EQ $body "Ada|hello world|Ada concatenated"
```
**Example: scoped env reverts**
```oxdock
# ENV inside a braced block reverts when the block exits
ENV MODE=production
[bool:true] {
ENV MODE=staging
WRITE inner.txt "{{ env:MODE }}"
}
WRITE outer.txt "{{ env:MODE }}"
LET $inner_body: STRING = READ inner.txt
LET $outer_body: STRING = READ outer.txt
ASSERT_EQ $inner_body "staging"
ASSERT_EQ $outer_body "production"
```
### INHERIT_ENV
Inherit env vars from host.
**Syntax:** `INHERIT_ENV [<key>, ...]`
Declares which host environment variables to inherit into the script.
Must appear before any other commands and at most once. Without this
directive, the script starts with an empty environment.
**Arguments:**
| `keys` | [`STRING...`](#value-type-string) | no | Host variables to inherit |
**Examples:**
**Example: inherit env**
```oxdock
INHERIT_ENV [PATH, HOME]
```
### ECHO
Print to stdout.
**Syntax:** `ECHO <message>`
Outputs message to stdout.
**Arguments:**
| `message` | [`STRING...`](#value-type-string) | yes | Text |
**Output:** Stdout
**Examples:**
**Example: echo**
```oxdock
ECHO build-complete
```
**Example: variables**
```oxdock
# a lone $x evaluates; {{ }} interpolates inside text
LET $x: STRING = "World"
ECHO {{ $x }}
ECHO $x
ASSERT_CONTAINS stdout "World"
```
### RUN
Execute shell command or direct executable.
**Syntax:** `RUN <command...> | RUN ["exe", "arg", ...]`
Shell form (`RUN <command...>`) runs the joined command string in the
system shell (`$SHELL -c` / `COMSPEC /C`).
Exec form (`RUN ["exe", "arg", ...]`) spawns the executable directly
with no shell, so there is no shell expansion, globbing, redirection,
or pipes; use it for portable commands.
Guards and wrappers (`ASYNC`, `TIMEOUT`, `WITH_IO`, `LET`) apply to
both forms.
**Arguments:**
| `command` | [`STRING...`](#value-type-string) | yes | Command |
**Examples:**
**Example: run**
```oxdock
RUN echo hello
```
**Example: run exec form**
```oxdock
RUN ["cargo", "--version"]
```
### COPY
Copy file into workspace.
**Syntax:** `COPY [--from-current-workspace] <from> <to>`
Copies from host.
**Arguments:**
| `from` | [`PATH`](#value-type-path) | yes | Source |
| `to` | [`PATH`](#value-type-path) | yes | Dest |
**Flags:**
| `--from-current-workspace` | `BOOL` | Copy from workspace instead of build context |
**Examples:**
**Example: copy**
```oxdock roots:unified
WRITE src.txt content
COPY src.txt dst.txt
LET $body: STRING = READ dst.txt
ASSERT_EQ $body "content"
```
**Example: copy from workspace**
```oxdock roots:unified
WRITE ws-src.txt ws-content
COPY --from-current-workspace ws-src.txt ws-copy.txt
LET $body: STRING = READ ws-copy.txt
ASSERT_EQ $body "ws-content"
```
### COPY_GIT
Copy from git revision.
**Syntax:** `COPY_GIT [--include-dirty] <rev> <src> <dst>`
Checkout and copy.
**Arguments:**
| `rev` | [`STRING`](#value-type-string) | yes | Rev |
| `src` | [`PATH`](#value-type-path) | yes | Src |
| `dst` | [`PATH`](#value-type-path) | yes | Dst |
**Flags:**
| `--include-dirty` | `BOOL` | Include dirty |
**Examples:**
**Example: git copy**
```oxdock expect_error:"COPY source missing"
COPY_GIT HEAD src.txt dst.txt
```
**Expected error:** `COPY source missing`
### SYMLINK
Create symlink.
**Syntax:** `SYMLINK <from> <to>`
Creates symlink.
**Arguments:**
| `from` | [`PATH`](#value-type-path) | yes | Target |
| `to` | [`PATH`](#value-type-path) | yes | Link |
**Examples:**
**Example: symlink**
```oxdock roots:unified
WRITE original.txt content
SYMLINK original.txt link.txt
LET $body: STRING = READ link.txt
ASSERT_EQ $body "content"
```
### MKDIR
Create directory.
**Syntax:** `MKDIR <path>`
Creates dir with parents.
**Arguments:**
| `path` | [`PATH`](#value-type-path) | yes | Dir path |
**Examples:**
**Example: mkdir**
```oxdock
MKDIR deeply/nested/tree
```
### LS
List directory.
**Syntax:** `LS [<path>]`
Lists entries.
**Arguments:**
| `path` | [`PATH`](#value-type-path) | no | Dir |
**Output:** Stdout
**Examples:**
**Example: ls**
```oxdock
MKDIR inventory
WRITE inventory/a.txt a
LS inventory
```
### CWD
Print working directory.
**Syntax:** `CWD`
Outputs cwd.
**Output:** Stdout
**Examples:**
**Example: cwd**
```oxdock
CWD
```
### READ
Read file to stdout.
**Syntax:** `READ [<path>]`
Outputs file contents.
**Arguments:**
| `path` | [`PATH`](#value-type-path) | no | File |
**Output:** Stdout
**Examples:**
**Example: read**
```oxdock
WRITE note.txt "hello"
READ note.txt
```
### READ_LINE
Read one line from stdin into a variable.
**Syntax:** `READ_LINE $var`
Reads bytes until newline without waiting for EOF, leaving the pipe open.
Trailing newline is stripped (shell-read parity). On premature EOF
assigns accumulated bytes and returns.
**Arguments:**
| `var` | [`STRING`](#value-type-string) | yes | Target variable (`$name`); the line binds as STRING |
**Examples:**
**Example: read line**
```oxdock
LET $lines: PIPE
WITH_IO [stdout=$lines] ECHO "first"
WITH_IO [stdin=$lines] READ_LINE $reply
```
### WRITE
Write to file.
**Syntax:** `WRITE <path> [<contents>]`
Writes contents.
**Arguments:**
| `path` | [`PATH`](#value-type-path) | yes | File |
| `contents` | [`STRING...`](#value-type-string) | no | Content |
**Examples:**
**Example: write**
```oxdock
WRITE output.txt hello-world
```
### APPEND
Append to file.
**Syntax:** `APPEND <path> [<contents>]`
Appends contents.
**Arguments:**
| `path` | [`PATH`](#value-type-path) | yes | File |
| `contents` | [`STRING...`](#value-type-string) | no | Content |
**Examples:**
**Example: append**
```oxdock
WRITE log.txt line1
APPEND log.txt line2
LET $all: STRING = READ log.txt
ASSERT_EQ $all "line1line2"
```
### EXPAND
Expand a template file (or stdin) to stdout.
**Syntax:** `EXPAND [<path>] [<KEY=val> ...]`
A template is any text file — or piped stdin when no path is given —
containing `{{ ... }}` placeholders. EXPAND replaces each placeholder
and prints the result to stdout.
Placeholders: `{{ NAME }}` reads a `KEY=val` override passed on this
command; `{{ env:NAME }}` reads an override, falling back to the
environment; `{{ $var }}` reads a script variable (dotted paths allowed).
A missing key is an error, never a silent empty.
Substitution runs in a single pass. EXPAND is not recursive and does not
expand nested placeholders: a value that itself contains `{{ ... }}` is
inserted verbatim and never expanded again.
A bare `$var` argument is a template path; `KEY=val` arguments are
overrides whose values follow the unified string-value rules (same as
`ENV`: quotes keep exact bytes, a lone `$var` evaluates,
`{{ ... }}` interpolates).
NOTE: `WRITE` interpolates `{{ ... }}` while writing, so escape it
(`\{{ ... }}`) when writing a template file for a later `EXPAND`.
With no path, the template arrives on stdin through a pipe. When piping
from a shell, single-quote the template (`echo '{{ $x }}'`): double
quotes let the shell swallow `$x`, so oxdock receives an empty `{{ }}`
placeholder and errors.
**Arguments:**
| `path` | [`PATH`](#value-type-path) | no | Template file to expand; omit to expand stdin |
| `overrides` | [`STRING...`](#value-type-string) | no | Template overrides shadowing that key (unified string values) |
**Output:** Stdout
**Examples:**
**Example: expand**
```oxdock
ENV NAME="Alice"
WRITE template.md "Hello {{ env:NAME }}!"
EXPAND template.md
ASSERT_CONTAINS stdout "Hello Alice!"
```
**Example: override with spaces**
```oxdock
# WRITE would interpolate {{ }} right away, so escape it:
# the file must literally contain {{ env:NAME }} for EXPAND
WRITE template.md "Hello \{{ env:NAME }}!"
EXPAND template.md NAME="Alice Smith"
ASSERT_CONTAINS stdout "Hello Alice Smith!"
```
**Example: variable override**
```oxdock
# same escaping: keep the placeholder literal until EXPAND;
# a lone $who evaluates, like ECHO $who
LET $who: STRING = "Bob"
WRITE template.md "Hi \{{ env:WHO }}!"
EXPAND template.md WHO=$who
ASSERT_CONTAINS stdout "Hi Bob!"
```
**Example: override forms agree**
```oxdock
# a bare variable and a template-with-tail expand identically
LET $x: STRING = "Ada"
WRITE template.md "Hi \{{ env:NAME }} and \{{ env:NAME2 }}!"
EXPAND template.md NAME=$x NAME2="{{ $x }} concatenated"
ASSERT_CONTAINS stdout "Hi Ada and Ada concatenated!"
```
**Example: expand stdin**
```oxdock
# no path: the template arrives on stdin through a pipe
LET $tpl: PIPE
WITH_IO [stdout=$tpl] ECHO "Hello \{{ env:NAME }}!"
WITH_IO [stdin=$tpl] EXPAND NAME=Alice
ASSERT_CONTAINS stdout "Hello Alice!"
```
**Example: override does not leak**
```oxdock
# KEY=val overrides shadow env for that EXPAND only —
# they never update the environment itself
ENV NAME="Alice"
WRITE template.md "Hi \{{ env:NAME }}!"
EXPAND template.md NAME="Bob"
ASSERT_CONTAINS stdout "Hi Bob!"
EXPAND template.md
ASSERT_CONTAINS stdout "Hi Alice!"
```
### ASSERT_EQ
Assert strict equality.
**Syntax:** `ASSERT_EQ <actual> <expected> | ASSERT_EQ --hash <sha256> <actual>`
Compares two evaluated values with typed equality (no coercion:
`INT(42)` never equals `STRING("42")`), aborting the pipeline
with a step-numbered error showing expected vs actual otherwise.
Both sides are values: `$var`, literals, templates, and calls
evaluate in memory and never touch disk. Read files explicitly
first (`LET $text: STRING = READ "out.txt"`, then
`ASSERT_EQ $text ...`).
Bare `stdout` / `stderr` observe stream buffers; a `$var`
holding a `PIPE` observes its backend bytes. `--hash` compares
the SHA-256 of a string, pipe, or captured-stdout actual
instead of the raw bytes (`stderr` is unsupported).
**Arguments:**
| `actual` | `<any>` | yes | Value, stdout, stderr, or a $var holding a PIPE |
| `expected` | `<any>...` | no | Expected (required unless --hash) |
**Flags:**
| `--hash` | `STRING` | SHA-256 |
**Examples:**
**Example: assert eq**
```oxdock
LET $status: INT = 200
ASSERT_EQ $status 200
```
**Example: assert eq file**
```oxdock
WRITE payload.bin stable-content
LET $body: STRING = READ payload.bin
ASSERT_EQ $body "stable-content"
```
**Example: assert eq hash**
```oxdock
# --hash compares the SHA-256 digest instead of raw bytes
WRITE payload.bin stable-content
LET $body: STRING = READ payload.bin
ASSERT_EQ --hash 08135c1b6349b0e4f894c36221952f0de00e6b4d82f80895abf359755e77103c $body
```
### ASSERT_CONTAINS
Assert containment.
**Syntax:** `ASSERT_CONTAINS <haystack> <needle>`
Checks containment and aborts the pipeline with a step-numbered
error otherwise: substring for strings, element match for lists,
key presence for maps, substring over stream and pipe buffers.
Like `ASSERT_EQ`, both sides are values read without implicit
I/O; read files explicitly first
(`LET $text: STRING = READ "cfg.txt"`).
Bare `stdout` / `stderr` observe stream buffers; a `$var`
holding a `PIPE` observes its backend bytes.
**Arguments:**
| `haystack` | `<any>` | yes | Value, stdout, stderr, or a $var holding a PIPE |
| `needle` | `<any>...` | yes | Substring, element, or key |
**Examples:**
**Example: assert contains**
```oxdock
ECHO build-complete
ASSERT_CONTAINS stdout "build-complete"
```
### HASH_SHA256
Print SHA-256.
**Syntax:** `HASH_SHA256 <path>`
Computes digest.
**Arguments:**
| `path` | [`PATH`](#value-type-path) | yes | File |
**Output:** Stdout
**Examples:**
**Example: hash**
```oxdock
WRITE payload.txt hello
HASH_SHA256 payload.txt
```
### EXIT
Exit pipeline.
**Syntax:** `EXIT <code>`
Stops the pipeline immediately with an `EXIT requested with code <code>`
error; steps after it never run, at any nesting depth.
Enclosing blocks still unwind their LET/ENV/WORKDIR/WORKSPACE state,
anonymous background tasks are killed synchronously, and files written
before the EXIT persist.
**Arguments:**
| `code` | [`INT`](#value-type-int) | yes | Code |
**Examples:**
**Example: exit**
```oxdock expect_error:"EXIT requested with code 0"
EXIT 0
```
**Expected error:** `EXIT requested with code 0`
### SLEEP
Pause execution for a duration.
**Syntax:** `SLEEP <duration>`
Parks the step for the duration (e.g. 500ms, 10s, 2m).
Cooperative: checks for cancellation so an enclosing TIMEOUT or task
teardown interrupts the sleep. Cross-platform alternative to shell sleep
for testing time boundaries.
**Arguments:**
| `duration` | [`DURATION`](#value-type-duration) | yes | How long to sleep |
**Examples:**
**Example: sleep**
```oxdock
SLEEP 100ms
```
**Example: sleep variable duration**
```oxdock
# durations resolve at runtime, so variables work too —
# quoted or bare, both bind the same string
LET $pause: STRING = "100ms"
SLEEP $pause
LET $bare: STRING = 100ms
SLEEP $bare
```
### LIST_APPEND
Append an item to a LIST variable in place.
**Syntax:** `LIST_APPEND $list <item>`
Appends the item to the LIST variable in place.
When the binding holds the only reference the push runs in
amortized constant time. Aliased buffers detach first, so
other holders keep their contents.
**Arguments:**
| `list` | [`LIST`](#value-type-list) | yes | Target LIST variable (`$name`) |
| `item` | `<any>` | yes | Item to append (any value) |
**Examples:**
**Example: list append**
```oxdock
LET $items: LIST = []
LIST_APPEND $items "first"
LIST_APPEND $items "second"
LET $want: LIST = ["first", "second"]
ASSERT_EQ $items $want
```
## Value types
### Value type: INT
64-bit signed integer, e.g. an exit code.
### Value type: FLOAT
64-bit float, e.g. a ratio.
### Value type: STRING
Arbitrary text. Quotes keep exact bytes, lone `$var` evaluates, `{{ ... }}` interpolates.
### Value type: BOOL
Boolean `true` or `false`.
### Value type: LIST
Ordered list of values. Shared heap: cloning bumps a refcount.
### Value type: MAP
String-keyed map of values. Shared heap: cloning bumps a refcount.
### Value type: PATH
Workspace path, resolved against cwd and guarded against escape.
### Value type: DURATION
Positive time span: `500ms`, `10s`, `2m`, `1h`; bare number means seconds.
### Value type: PIPE
Anonymous pipe handle. The backend materializes lazily on first
binding (never eagerly at declaration), so the choice always has full
usage context. Cloning shares the backend (explicit-sharing fan-out);
equality is handle identity, never byte comparison.
### Value type: HANDLE
Background ASYNC task handle for AWAIT/CANCEL.
### Value type: SEMAPHORE
Counting semaphore for admission control. Cloning shares the backend
(explicit-sharing fan-out); equality is handle identity, never the
count.
### Value type: PERMIT
Opaque admission permit minted by `SEMAPHORE_TRY_ACQUIRE`. Cloning
shares the release obligation (first drops release nothing, the last
releases once); equality is handle identity.
## Functions
Callable as `MODULE::NAME(...)` in expressions (or bare `NAME(...)` with the module imported via `IMPORT`). Introspectable from scripts with `FUNCTIONS()` and `DESCRIBE(name)`.
### STD::DESCRIBE
**Signature:** `STD::DESCRIBE($name: STRING) -> MAP`
**Contexts:** AST only
Describe one function by qualified name.
Returns a MAP with name, module, kind, params, returns, and summary.
Bare names fail closed: `DESCRIBE` requires the qualified form (except
`INSPECT`, which is syntax rather than a registry entry). Errors on
unknown function.
### STD::FLOAT
**Signature:** `STD::FLOAT($val) -> FLOAT`
**Contexts:** AST, RPN
Convert a value to FLOAT.
Parses f64 (accepts int strings), bails on non-finite or non-numeric.
### STD::FUNCTIONS
**Signature:** `STD::FUNCTIONS() -> LIST`
**Contexts:** AST only
List all visible function names.
Sorted LIST of qualified `MODULE::NAME` entries: DSL-defined plus native
plus host-registered names.
### STD::GLOB
**Signature:** `STD::GLOB($pattern: STRING) -> LIST`
**Contexts:** AST, RPN
List workspace paths matching a glob pattern.
Sorted, root-relative LIST; empty on no match or `..` escape.
### STD::INT
**Signature:** `STD::INT($val) -> INT`
**Contexts:** AST, RPN
Convert a value to INT.
Trims ASCII whitespace and parses i64. Passes Int through; Float only
when integral and finite.
### STD::IS_TERMINAL
**Signature:** `STD::IS_TERMINAL($stream: STRING) -> BOOL`
**Contexts:** AST only
Report whether a standard stream is a terminal.
`IS_TERMINAL("stdin")`, `IS_TERMINAL("stdout")`, or `IS_TERMINAL("stderr")`
answers for the step's stream as currently bound, so scripts can adapt
prompts, colors, and progress output. Anything diverted from the
terminal reports false without touching host handles: `WITH_IO` pipe
bindings (script backends and OS pairs), `LET`-capture sinks, staged
runner sinks, and any materialized stdin stream (only a directly
inherited fd falls back to the process check). A transparent root tee
still answers the session question via the process check. The name
matches exactly (no case folding): anything else bails. AST-only:
reads the step context like the other introspection functions.
### STD::LOAD_JSON
**Signature:** `STD::LOAD_JSON($path: STRING) -> MAP`
**Contexts:** AST, RPN
Load and parse a JSON file.
Reads a workspace file and parses JSON into a DSL value.
### STD::LOAD_TOML
**Signature:** `STD::LOAD_TOML($path: STRING) -> MAP`
**Contexts:** AST, RPN
Load and parse a TOML file.
Reads a workspace file and parses TOML into a DSL value.
### STD::PATH_TYPE
**Signature:** `STD::PATH_TYPE($path: STRING) -> STRING`
**Contexts:** AST only
Describe a filesystem entry.
Reports file, dir, symlink (no-follow), or absent. AST-only by design;
there is no RPN arm for filesystem IO.
### STD::SEMAPHORE_AVAILABLE
**Signature:** `STD::SEMAPHORE_AVAILABLE($sem) -> INT`
**Contexts:** AST, RPN
Read free permits under the lock, with no mutation.
Observability only (audit lines, healthchecks: `active = max - free`).
Exact at read time and stale the instant the caller acts on it, so it
must never drive admission: that is `SEMAPHORE_TRY_ACQUIRE`'s job.
```text
LET $free: INT = SEMAPHORE_AVAILABLE($sem)
```
### STD::SEMAPHORE_NEW
**Signature:** `STD::SEMAPHORE_NEW($max: INT) -> SEMAPHORE`
**Contexts:** AST only
Create a counting semaphore admitting at most `max` concurrent holders.
Non-positive maxima bail. The word names a shared backend: every clone
observes the same count, and admission runs through
`SEMAPHORE_TRY_ACQUIRE`, never through the `SEMAPHORE_AVAILABLE`
readout.
```text
LET $sem: SEMAPHORE = SEMAPHORE_NEW(10)
```
### STD::SEMAPHORE_TRY_ACQUIRE
**Signature:** `STD::SEMAPHORE_TRY_ACQUIRE($sem) -> MAP`
**Contexts:** AST only
Attempt one non-blocking acquire, always answering a MAP.
`held` is `1` with the permit under the `permit` key, or `0` with no
`permit` key: branch on `$m.held` (the DSL has no null, so the absent
key is the miss shape, and missing-key access already bails strictly).
Never waits, so no wait can wedge.
```text
LET $acq: MAP = SEMAPHORE_TRY_ACQUIRE($sem)
IF $acq.held == 0 {
ECHO "at cap, rejecting"
} ELSE {
LET $permit: PERMIT = $acq.permit
ASYNC { session work }
}
```
### STD::TYPES
**Signature:** `STD::TYPES() -> LIST`
**Contexts:** AST only
List all known type names.
Sorted LIST of startup plus host-registered type descriptors. Reads the
run's name directory, so it runs on the AST path like the other
introspection functions.
### STD::TYPE_DESCRIBE
**Signature:** `STD::TYPE_DESCRIBE($name: STRING) -> MAP`
**Contexts:** AST only
Describe one type by name.
Returns a MAP with name, summary, and docs. Errors on unknown type.
Reads the run's name directory, so it runs on the AST path.