WASI arguments and environment, and the shapes resource imports will need

:args and :env are the two parts of the WASI config that need an array of C
strings rather than one call each, so they are where the wiring can be wrong
without the boolean capabilities noticing. dev/resources/args/ is a guest that
asks WASI how many arguments it has -- the smallest observable consequence --
and the test walks 0, 1, 3 and 5 of them.

Deny-by-default holds here too: no :args means no arguments, not the host's.

I picked this over resource imports deliberately and say so: resource imports
are a multi-turn feature and this is a complete one. What that unit needs is
now read from the headers and written into 0017 F, so it starts on the shapes
rather than looking for them --

  resource_type_new_host(uint32_t ty)
  linker_instance_add_resource(li, name, len, type,
                               void (*dtor)(void*, wasmtime_context_t*, uint32_t),
                               data, finalizer)
  resource_host_new(bool owned, uint32_t rep, uint32_t ty)

-- a u32 type tag, a destructor upcall of a second shape, and handles minted
per call, with resource_host_to_any the conversion that panics outside a call
scope.

One slip: Arena.allocate(MemoryLayout, long) does not exist on this JVM, so the
pointer array is allocated as bytes. Caught by running it.

211 assertions.

Claude-Session: https://claude.ai/code/session_01XF5Hfq4Ca2N2XYEzWQQuHt

Author: chaploud

dev/resources/args.wat

@@ -0,0 +1,14 @@
+;; The guest half of dev/resources/args/: it asks WASI how many arguments it
+;; was given, which is the smallest observable consequence of `:args`.
+(module
+  (import "wasi:cli/environment@0.2.0" "get-arguments" (func $ga (param i32)))
+  (memory (export "memory") 1)
+  (global $next (mut i32) (i32.const 1024))
+  (func (export "cabi_realloc") (param i32 i32 i32 i32) (result i32)
+    (local $p i32)
+    (local.set $p (global.get $next))
+    (global.set $next (i32.add (local.get $p) (local.get 3)))
+    (local.get $p))
+  (func (export "argc") (result i32)
+    (call $ga (i32.const 128))
+    (i32.load offset=4 (i32.const 128))))

dev/resources/args/deps/cli/environment.wit

@@ -0,0 +1,8 @@
+// A hand-declared subset of the real wasi:cli@0.2.0, so this repo can check
+// `:args` and `:env` without vendoring the WASI WIT tree. The signatures are
+// the real ones; wasmtime satisfies them through add_wasip2.
+package wasi:cli@0.2.0;
+interface environment {
+  get-arguments: func() -> list<string>;
+  get-environment: func() -> list<tuple<string, string>>;
+}

dev/resources/args/world.wit

@@ -0,0 +1,5 @@
+package local:args@0.1.0;
+world w {
+  import wasi:cli/environment@0.2.0;
+  export argc: func() -> u32;
+}

doc/design/0017-host-imports.md

@@ -153,6 +153,22 @@ handles.
 
 The first draft listed this as a falsifier. It is not one waiting to fire.
 
+The shapes, read from the pinned headers so the next unit starts on them:
+
+```c
+wasmtime_component_resource_type_new_host(uint32_t ty);
+wasmtime_component_linker_instance_add_resource(
+    linker_instance, name, name_len, resource_type,
+    void (*destructor)(void *, wasmtime_context_t *, uint32_t rep),
+    void *data, void (*finalizer)(void *));
+wasmtime_component_resource_host_new(bool owned, uint32_t rep, uint32_t ty);
+```
+
+So a host resource is a `u32` type tag, a destructor upcall of a *second*
+shape, and handles minted per call. `resource_host_to_any` is how one becomes
+a val — and it panics outside a call scope, which is the landmine already
+recorded above.
+
 ## Alternatives rejected
 
 - **Imports on the artifact, sharing one set of host functions.** Wrong the

src/cljwit/host.clj

@@ -165,6 +165,8 @@
      :wasi-stderr   (b "wasi_config_inherit_stderr" nil ADDR)
      :wasi-stdin    (b "wasi_config_inherit_stdin" nil ADDR)
      :wasi-env      (b "wasi_config_inherit_env" nil ADDR)
+     :wasi-argv     (b "wasi_config_set_argv" ValueLayout/JAVA_BOOLEAN ADDR I64 ADDR)
+     :wasi-setenv   (b "wasi_config_set_env" ValueLayout/JAVA_BOOLEAN ADDR I64 ADDR ADDR)
      ;; 0017 C: wasmtime frees what an import callback writes, so a string
      ;; result cannot come from an Arena. libc's malloc is the allocator it
      ;; expects, and this is the only place in the library that needs one.
@@ -916,14 +918,28 @@
   "Adds every WASI 0.2 interface to the linker and gives the store a context.
    Deny-by-default: a capability is inherited only when named, because the
    alternative leaks the host's environment into the guest."
-  [api ^MemorySegment ctx clink {:keys [inherit-stdout inherit-stderr
-                                        inherit-stdin inherit-env]}]
+  [api ^Arena arena ^MemorySegment ctx clink
+   {:keys [inherit-stdout inherit-stderr inherit-stdin inherit-env args env]}]
   (ok! api "add_wasip2" (invoke (:add-wasip2 api) clink))
-  (let [cfg (invoke (:wasi-new api))]
+  (let [cfg (invoke (:wasi-new api))
+        strs (fn [xs]
+               (let [a ^MemorySegment (.allocate arena (long (* 8 (max 1 (count xs)))))]
+                 (dotimes [i (count xs)]
+                   (.set a ADDR (long (* 8 i)) ^MemorySegment (cstr arena (str (nth xs i)))))
+                 a))]
     (when inherit-stdout (invoke (:wasi-stdout api) cfg))
     (when inherit-stderr (invoke (:wasi-stderr api) cfg))
     (when inherit-stdin  (invoke (:wasi-stdin api) cfg))
     (when inherit-env    (invoke (:wasi-env api) cfg))
+    (when args
+      (when-not (invoke (:wasi-argv api) cfg (long (count args)) (strs args))
+        (throw (ex-info "wasi_config_set_argv refused the arguments"
+                        {:cljwit/error :wasi-config}))))
+    (when env
+      (when-not (invoke (:wasi-setenv api) cfg (long (count env))
+                        (strs (map key env)) (strs (map val env)))
+        (throw (ex-info "wasi_config_set_env refused the environment"
+                        {:cljwit/error :wasi-config}))))
     ;; The config is consumed even on error, so it is per-instantiate.
     (ok! api "set_wasi" (invoke (:set-wasi api) ctx cfg))))
 
@@ -946,7 +962,7 @@
         ;; report a trap with the cause gone.
          dead  (atom nil)
          _     (define-imports! api arena e ctx clink ct imports dead)
-         _     (when wasi (enable-wasi! api ctx clink wasi))
+         _     (when wasi (enable-wasi! api arena ctx clink wasi))
          inst  ^MemorySegment (.allocate arena (long INSTANCE))
          _     (ok! api "linker_instantiate"
                     (invoke (:instantiate api) clink ctx (.-ptr art) inst))

test/cljwit/host_test.clj

@@ -492,3 +492,23 @@
                 (is (integer? ((i "roll")))
                     "naming one capability does not break the rest")))))
         (finally (.delete ^File f))))))
+
+(deftest wasi-arguments
+  ;; `0017` E's remaining surface. `:args` and `:env` are the two that need an
+  ;; array of C strings rather than a single call, so they are the ones where
+  ;; the wiring can be wrong without the boolean capabilities noticing.
+  (if-not lib
+    (println "CLJWIT_WASMTIME_LIB unset — skipping wasi-args test")
+    (let [f (build-component! "args")]
+      (try
+        (with-open [e (host/engine)]
+          (with-open [a (host/compile e (io/file f))]
+            (testing "the guest sees exactly the arguments it was given"
+              (doseq [as [[] ["one"] ["a" "b" "c"] ["x" "y" "z" "w" "v"]]]
+                (with-open [i (host/instantiate a {:wasi {:args as}})]
+                  (is (= (count as) ((i "argc"))) (pr-str as)))))
+            (testing "and none when none are named — deny-by-default"
+              (with-open [i (host/instantiate a {:wasi {}})]
+                (is (= 0 ((i "argc")))
+                    "no :args means no arguments, not the host's")))))
+        (finally (.delete ^File f))))))