v0.5.0

Added

• Added a committed playground/ test environment that exercises full action
  coverage end-to-end against a real backend (#161).
• scoot-wasm now executes floating-point Wasm (W4): f32/f64 arithmetic
  (add/sub/mul/div), unary ops (abs/neg/ceil/floor/trunc/nearest/sqrt),
  min/max/copysign, ordered comparisons, int/float conversions, and both
  trapping (iNN.trunc_fMM_s/u) and saturating (iNN.trunc_sat_fMM_s/u)
  truncation, alongside the already-supported bulk memory.copy/memory.fill.
  NaN results are canonicalized for deterministic output across hosts, while
  abs/neg/copysign preserve exact bit patterns; nearest rounds ties to even
  and the zero sign is preserved. The static type validator now type-checks the
  float opcodes too, so float modules load and run end-to-end. A robustness
  suite now feeds truncated, byte-corrupted, and random/hostile module bytes
  through the loader and asserts every input yields a structured load error or
  trap instead of crashing. Full spec-conformant validation beyond the
  supported subset remains a later phase (#100).
• Added a native wasm_tool Agent action for compute-only local Wasm packages.
  It validates the package boundary, requires entry = "_start" plus
  policy.toml granting only compute, and runs the configured scoot-wasm
  host argv directly instead of giving the model a broad bash command.
  With the default host config, Scoot now prefers a sibling scoot-wasm next to
  the running scoot binary before falling back to PATH.
• Added a copyable Wasm compressor plugin template, a deterministic redactor
  compressor example, and scripts/check-wasm-examples.sh to build, validate,
  and smoke-test the example packages.
• scoot-wasm now performs a W3 static function-body type validation pass for
  the current host subset before execution. It checks operand/control stack
  shapes, block/loop/if signatures, branch labels, direct and indirect call
  signatures, local/global access, memory/table presence, and immutable globals,
  so malformed type/index errors fail module loading instead of reaching the
  interpreter. Full spec-conformant validation beyond the supported subset is
  still a later phase (#100).
• scoot-wasm now runs wasm32-wasi command modules over a minimal WASI
  preview1 subset (W2): scoot-wasm wasi <module.wasm> [args...] instantiates
  the module, runs _start, pipes this process's stdin to fd 0, forwards the
  module's stdout/stderr, and exits with its proc_exit status. The exposed
  surface is a pure data-transform sandbox: the only channels are stdin
  (fd_read, fd 0), stdout/stderr (fd_write, fd 1/2), argv (args_*), and
  proc_exit. No environment, clock, randomness, filesystem, or network is
  exposed — environ_*, clock_time_get, random_get, and every other WASI
  import trap by construction, so a plugin's output is a pure function of its
  (stdin, argv). Out-of-bounds guest pointers return EFAULT and non-stdio fds
  return EBADF. This is the intended subprocess host for external compression
  plugins (#100).
• scoot-wasm now executes integer Wasm functions (W1): a dependency-free Zig
  stack machine with structured control flow (block/loop/if/else/br/br_if/
  br_table/return/call/call_indirect), i32/i64 arithmetic, a bounds-checked
  64 KiB-page linear memory (load/store, memory.size/grow), globals, a funcref
  table, and active data/element segments. Every fault is a structured trap
  (unreachable, divide-by-zero, integer overflow, out-of-bounds memory/table,
  indirect-call type mismatch) bounded by fuel, call-depth, and memory-page
  limits. Invoke with scoot-wasm run <module.wasm> <export> [int args...].
  The engine is compiled only into the standalone scoot-wasm binary
  (-Dwasm-host=true); the zero-dependency core never links it. Full
  spec-conformant validation beyond the supported subset remains a later
  phase (#100).
• Release workflow now publishes a separate scoot-wasm-<target>.tar.gz archive
  (plus .sha256) for every target, built in the same job via
  -Dwasm-host=true. The optional standalone Wasm compute-unit host is now a
  downloadable artifact, not a build-from-source-only binary.
• Added a Homebrew tap publish job (brew install jamiesun/tap/scoot and
  brew install jamiesun/tap/scoot-wasm). The scoot-wasm formula depends on
  scoot, so installing the host also installs the agent; the default
  wasm_host then resolves scoot-wasm from PATH. The job no-ops unless a
  HOMEBREW_TAP_TOKEN secret is set, mirroring the optional Docker Hub publish.

Changed

• Release archives now ship a single ReleaseSafe flavor per target instead of
  both ReleaseSafe and ReleaseSmall. Users who need a smaller binary compile
  from source with -Doptimize=ReleaseSmall; the published release notes carry a
  permanent footer documenting this and the optional Wasm host.

Removed

• Dropped the -small (ReleaseSmall) release artifacts and the installer's
  SCOOT_INSTALL_FLAVOR variable. install.sh now downloads the single
  published flavor.
• Narrowed the Wasm plugin sandbox to stdin/stdout/stderr/argv as a new hard
  rule: no filesystem, network, clock, or randomness authority (#164).

Documentation

• Rewrote the README to be human-friendly and concept-first, and refreshed the
  infographic with an isometric hero image (#160, #165).
• Removed the redundant README language link and translated remaining Chinese
  comments and strings to English (#146, #153).

---

Install

curl -fsSL https://raw.githubusercontent.com/jamiesun/scoot/main/install.sh | sh

macOS (Homebrew):

brew install jamiesun/tap/scoot          # the agent
brew install jamiesun/tap/scoot-wasm      # optional Wasm compute-unit host (pulls in scoot)

Build flavors

Prebuilt archives are ReleaseSafe only (runtime safety checks on). If you
need a smaller binary, compile from source:

zig build -Doptimize=ReleaseSmall   # smallest, fewer safety checks

Each target also ships a separate scoot-wasm-* archive: the optional
standalone Wasm host. The zero-dependency core scoot binary never embeds it.