[chenyan2002]

This branch makes component-ui usable by agents. A command-line frontend runs a component
without its host, answers its imports from a file, and writes each run back as a file that
reproduces it. A skill teaches agents the workflow. To get there, the core is separated from
the UI and shared with the CLI, and values are read and written with proxy-component's WAVE
codec. The UI gains those features too: trap stacks, saving sessions, and answering imports
by default.

Command line (component-ui)

• inspect app.wasm lists:
  • the exports to call, and the host resources they use, whose functions can make arguments
  • the imports that ask for answers, and those answered on their own (constructors, and
    functions without a result)
  • the named types they use
• call app.wasm '<call>'… [--answers f] [--save f] runs calls on one instance. Calls are
  written as the console shows them: iface.func(1, "a"), new iface/res(1),
  iface/res.method(#borrow-res-1, …), drop #res-1, with WAVE arguments.
• The answers file is the run. It is checked strictly on replay.
  • > call lines, then each import the guest made, in order:
    • an answer, import(args) = value, or !trap to trap the guest
    • a hole, = ?, where the run stopped
    • a //! line for an import that didn't ask, e.g. //! imports/y.set-a(#borrow-y-1, 20)
      or //! drop #y-2
  • New mocks are written #mock-<id>, so later uses of the id point back to where it was
    created, and replay checks the mock gets that id.
  • A line that no longer matches the guest's calls stops the run, naming the line to
    restart from.
• The happy path past the file's end, --defaults none|careful|eager (default eager):
  • ok for results, and records and tuples of those
  • new mocks for handles, noting the instances passed over
  • --save marks these // default, for the agent to review
• Stops show:
  • the expected type, and the definitions of the named types it uses
  • where the call's instances came from
  • the instances the answer could use
• Exit codes: 0 when every call returned, 2 when an answer is needed, 3 when a call
  failed (e.g. trapped), 1 on errors.
• Traps list the guest's stack, demangled, without its runtime's frames:
  ! cannot block a synchronous task before returning
  at kv_store_component.wasm: <fastly::http::response::handle::ResponseHandle as core::ops::drop::Drop>::drop
  at kv_store_component.wasm: kv_store_component::…::kv_store::Entry::dtor
  at kv_test-….wasm: kv_test::write_entry
• JavaScript imports: --imports <pkg>=<file.js> implements imports in JavaScript, and
  template app.wasm <pkg> prints a module to start from. A function skipped because an
  argument is a mock says so, on its line and in a final warning.
• Running it: npm run build:cli builds dist-cli/component-ui.mjs, a bin that
  npm link puts on the PATH. It needs Node 23 or later, and restarts itself with
  --experimental-wasm-jspi where needed.

Agent skill (skills/component-ui/SKILL.md)

• The workflow: inspect, run with --save, fill in the ?, rerun.
• Reviewing defaults: when the guest probably expects an existing instance rather than a
  mock.
• Exploring: editing answers, e.g. to err(…) or !trap.
• Reading runs and traps: including that a panic right after an answer may mean the answer
  broke the host's contract, and that agents should ask for the original commented WIT, which
  components don't embed.
• Reference: WAVE and call syntax, the answers file format, options, and limits.
• Tested by two fresh agents with only the skill and the CLI. One made resource.wasm's
  test-imports() return ok. The other traced kv-store.wasm's handling of a GET request,
  and found that it sends its KV lookup twice. Their friction is fixed here: trap reporting,
  stack frames, inspect's sections, a full trace in the file, instance provenance in hints,
  and skill clarifications.

UI

• Trap stacks in the console, demangled.
• Console settings (gear button):
• how imports are answered: "Ask for every result", "Fill in obvious results", or "Fill in,
  preferring new mocks", the CLI's three levels; defaulted answers are marked // default
• Save logs, which writes the session as an answers file the CLI replays and continues
• Clear logs
• The instance picker shows each instance's provenance as a tooltip.
• The console shows the guest's drops of host instances.
• Visible changes from the shared WAVE writer:
• none record fields are omitted
• both quote kinds are escaped
• floats have no exponents
• a borrow is #borrow-x-1 (was #borrowed-x-1)
• a method is labelled iface/res.method(#borrow-x-1, …) (was #borrowed-x-1.method(…))
• a list<u8> of text shows as b"…"

Core changes

• Core and UI separated (src/platform*.ts, src/log.ts). In Node, the core uses the
  browser build of preview2-shim: its Node build exits the process on wasi:cli/exit, leaks
  the host's environment, and keeps global state.
• Structured call records (src/call-record.ts): interface, resource, kind, function,
  WAVE arguments with a method's self first, and a callee.
• One call log for UI and CLI (src/call-log.ts): calls, imports, output and instance
  creations, in order. The console renders it; the CLI prints it and writes answers files
  from it.
• WAVE from proxy-component's fork of wasm-wave, in crates/bindgen (format/parse).
  The UI and CLI write values exactly as proxy-component does. The parser checks handle labels
  as strictly as proxy-component, and adds #mock, #mock-<id> and b"…".
• demangle in crates/bindgen, with rustc-demangle and cpp_demangle. It adds 62 KB
  to the gzipped bindgen.
• Shared answering (src/answering.ts): the happy path, promptContext, defaultAnswer
  and answerPrompt, used by both the driver and the console.

Docs

• docs/proxy-component-gap.md: where component-ui and proxy-component differ (trace format,
  names, handles, coverage), what now matches (the value encoding), and how answers files
  relate to proxy-component's traces.
• README: features, the command line, how it works, and known limitations:
• imports can't ask from resource destructors, during instantiation, or from exported
  constructors and statics, all because of where jco can suspend
• the embedded WIT lacks doc comments
• WASI isn't recorded or deterministic
• wasi:cli/exit isn't reflected in the exit code

Testing

• npm run test:node, 30 tests, covering:
• the core in Node
• the WAVE codec: proxy-component's output, round trips, handles, b"…", #mock-<id>
• demangling and frame filtering
• the CLI end to end: holes, --save replays, divergences, defaults levels, traps, mocks
  in call arguments, drops, JavaScript imports
• Playwright, 33 tests, updated for the new labels and formats, plus new tests for Save logs,
  the defaults levels, and trap frames.
• CI runs the Node tests in their own job, on Node 24, the version for both workflows now:
  Node 22's V8 lacks WebAssembly.Suspending.

Not in this PR

• An MCP server, which would keep a guest suspended between tool calls. It can be built on
  the shared driver.
• Deterministic WASI (seeded random numbers, fixed clocks), which would make replays exact
  where guests use them.
• Interop with proxy-component traces. The gap and the remaining steps are documented.
• Answering imports from resource destructors. It needs jco to return synchronous answers
  from its JSPI trampolines.