v0.11.0

Added

• A working WASI 0.2 HTTP example in examples/http, with vendored interfaces,
  a smoke-test script, and provider-neutral deployment guidance. The HTTP scaffold
  sets content type, escapes reflected text, and releases request/body resources.
• A complete symmetric Component Model round-trip component and automated
  matrix against two independent Rust seeds, in both directions and against
  itself. Coverage includes stable WIT values, nested compounds, owned/borrowed
  resources, constructors, methods, statics, and zero/multiple parameters.
• User-defined DefFunctor templates with named type parameters and concrete
  Instantiate expansion, including resource and compound-result templates.
• Dual-role imports using roles: {runtime macro} to share one alias between
  compile-time macros and runtime functions.
• User-declared DefResource resources; compiled cells; persistent resource
  state; resource methods, statics, constructors, and destructors.
• Tuple constructors tuple0 through tuple16, tuple argument bundling,
  payloadless results, bound variant/enum constructors, and constructor aliases.
• Compiled numeric conversions, f32, flags, collections, string operations,
  statically resolved map/filter/fold, and compound-value printing.
• Cross-package signature types, dependency aliases, named functor application,
  typed macro trees, pattern exhaustiveness, and cross-component type checking.
• Contextual callback typing and inference for recursive functions, cells,
  imported resource methods, and exported parameter/result annotations.
• An independent execution regression corpus, output comparison, and official
  WAVE-parser checks for documented values and backend float/character output.
• Shared private build staging with automatic cleanup, explicit path errors,
  duplicate filename rejection, and copied WIT/macro dependencies.
• Formatting, Clippy, Lizard complexity, module/function-size, and measured
  LLVM coverage gates in scripts/check.sh and CI. Existing complexity debt
  has checked-in ratchets; functions cannot reach 1,000 code lines.
• Pinned copy/paste detection for implementation Rust and JavaScript/TypeScript,
  with a content-based baseline that rejects new clones and extra copies.
• Interactive line editing, persistent REPL history, and executable .wlt or
  extensionless scripts using a leading shebang.

Changed

• Static typing is now the default language behavior. Unknown runtime types,
  heterogeneous lists, function-valued runtime storage/returns, and dynamic
  callback selection are rejected. Statically resolved functions and macros
  remain supported. --strict is accepted for compatibility.
• / in a name normalizes to -; qualified-symbol AST and macro-wire variants
  have been removed. Rebuild macro components against the updated meta ABI.
  The docs, language server, and all editor grammars follow the new spelling.
• wavelet run and the REPL execute compiled components and surface build
  errors or traps directly. The interpreter remains the reference oracle.
• Repeated REPL expressions reuse a bounded cache of compiled instances;
  definitions invalidate it, and value redefinitions replace older bindings.
• Local resource calls use borrowed arguments. Owned transfers are supported
  at Component Model import/export boundaries; unsupported local owned
  transfers are rejected rather than silently diverging between engines.
• Resource state is restricted to plain data or one outer cell containing
  plain data. Nested/shared cell graphs and function-bearing state are rejected
  before persistence.
• Per-call arenas reset between exported calls while resource state persists.
  Runtime helper emission is split into smaller modules and functions.
• If and Do are standard-library macros. The is a static ascription;
  conditions must be bool; integer literals must fit their contextual type;
  float literals are not Match patterns. A list argument binds to one parameter.
• Floats print indicatively to six significant digits. Empty tuples and unit
  retain their documented diagnostic spellings; the WAVE check records its
  single empty-tuple syntax exception explicitly.
• Source comments have been removed; agent guidance requires explanations in
  documentation and preserves executable/tool directives. Work happens in the
  shared checkout with local commits.
• The official source extension is .wlt.

Fixed

• GitHub releases include Windows x86-64 CLI and language server binaries and
  publish once checks and all platform builds pass.

• Builds preserve authored wit/*.wit files and publish fetched dependencies only
  after all staged fetches succeed. Duplicate packages and colliding component
  filenames and package names that escape the output directory fail before output
  files are written; empty build/run/compose inputs
  return diagnostics.

• Macro component caching distinguishes requested versions and explicit artifact
  paths. WIT dependencies accept binary and text-encoded WebAssembly packages.

• Imported WIT types retain package and interface identity, including aliases;
  colliding record layouts and resource names no longer overwrite one another.
  Passing a handle to a different resource interface is rejected statically.

• Imported single-field record results lift correctly through the canonical ABI.

• The embedded runtime uses Wasmtime 50, which runs the composed resource and
  variant regression that failed in the previous runtime's adapter compiler.

• Variant constructors shadow builtins consistently, including boxed calls;
  multi-field variant payloads use an explicit tuple type.

• Checked neg/abs overflow agrees in the interpreter and both backend paths.

• Speculative type inference cannot overwrite authoritative backend types.

• Interpreter ownership transfer invalidates the source handle; borrowed handles
  remain borrowed, and destructors run once at teardown.

• Tuple/record/variant pattern binding and coverage, canonical layout for narrow
  values and flags, dependency type aliases, resource compound results, and
  local overload resolution agree with their declared types.

• Strings containing ASCII controls, including NUL, print valid WAVE escapes in
  both engines. Float/character formatting and compound printing agree.

• wkg dependency fetching uses the current CLI directory syntax.

Removed

• Runtime read and apply; use compiler-side reading and direct calls.
• Interpreter fallback for failed CLI/REPL execution.
• Qsym values and their macro ABI representation.

What's Changed

• docs: correct stale phase status in check.rs header by @logaan in #33
• Reorganise the work plan vault into eight ordered goals by @logaan in #34
• docs: stop pointing CLAUDE.md at the deleted dev-notes/design.md by @logaan in #35
• test(differential): F4 execution harness — docs examples, interpreter vs compiled by @logaan in #36
• refactor(emit): split the 14.6k-line emit.rs into a module tree by @logaan in #39
• refactor(emit): split Emitter::builtin into per-group helpers by @logaan in #38
• fix: run extensionless shebang scripts, not just .wlt files by @logaan in #37
• Add fixed-arity tuple constructors tuple0..tuple16; values callee passes (decision 0.1) by @logaan in #41
• to-string: float and char arms in the wasm backend (0.2) by @logaan in #40

Full Changelog: v0.10.0...v0.11.0