0017 A: the per-instantiate linker stays, and 0014 C's instantiate figure was C's

0017 A argued stubs must be engine-scoped, on a 7 us upcall stub against a
20 us instantiate. Both numbers were on the wrong side of the boundary.
Measured through cljwit.host itself:

  instantiate, no imports   56.9 us
  instantiate, one import   73.2 us

So an import costs +16 us -- stub, import reflection and linker registration
together -- on a 57 us baseline, not 7 us on 20.

The prediction recorded before measuring was that reusing one linker across
instantiates would save 2x or more. It works -- wasmtime does not refuse it --
and it saves 1.23-1.45x in C. Falsified.

Against that, engine-scoped stubs need routing through the store data pointer
to reach a per-instance Clojure function, which is exactly where 0018's review
found destructor routing gets hard. So per-instantiate stays, and the falsifier
is named: a component whose own imports number in the dozens. WASI is not one,
because add_wasip2 supplies its interfaces without a stub each.

Separately, 0014 C's cost table said instantiate is 0.02 ms. That is a C
probe's number; this library pays 56.9 us for the same step, because
instantiate makes many FFM calls and each pays the flat crossing 0013 priced.
The ratio the decision rests on survives -- compilation is still 30-300x
instantiation -- but the figure was not ours, which is the same family of
mistake as 0011's whole cost accounting.

That unblocks 0018, which was deferred on this question.

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

Author: chaploud

doc/design/0014-cljwit-host-api.md

@@ -62,7 +62,13 @@ They differ by three orders of magnitude in cost and by everything in scope:
 |---|---|---:|
 | `engine` | process-wide, shared by everything | ~0 ms warm |
 | `compile` | Cranelift compilation of one component | **1.6 ms** (2.4 KB) … **19.2 ms** (103 KB) |
-| `instantiate` | a store plus an instance | 0.02 ms |
+| `instantiate` | a store plus an instance | 0.02 ms in C, **0.057 ms through `cljwit.host`** |
+
+**Corrected 2026-07-30:** the 0.02 ms is a C probe's. `cljwit.host` measures
+**56.9 µs** for the same step, because `instantiate` makes many FFM calls and
+each pays the flat crossing `0013` priced. The ratio the decision rests on
+survives — compilation is still 30–300× instantiation — but the absolute figure
+was not this library's.
 
 Compilation is 80–1000× instantiation and scales with module size. Fusing them
 would make `wasmtime_component_serialize`/`deserialize_file` unreachable, and

doc/design/0017-host-imports.md

@@ -30,15 +30,30 @@ What is settled, measured 2026-07-30:
 The identity is the exact WIT name, `iface#func`, as `0014` B decided. One
 naming rule for both directions.
 
-**The stubs should not be per-instance, even though the functions are.**
-`Linker.upcallStub` measures **~7 µs warm and 30–160 µs cold**, against a 20 µs
-instantiate; a fresh closure per request means a fresh stub and a fresh linker
-per request. The shape that avoids it — one stub per import *name*, cached on
-the artifact, dispatching through the store's data pointer
-(`wasmtime_store_new(engine, data, finalizer)` / `wasmtime_context_get_data`,
-both present in 47.0.1) to the per-instance Clojure function — keeps A's
-per-request state and makes stubs and linker engine-scoped. **Unimplemented and
-unverified**; recorded because the naive shape has a measured cost.
+**Amended 2026-07-30: the per-instantiate linker stays, measured.** The first
+version of this paragraph argued that stubs must be engine-scoped, on a 7 µs
+stub against a 20 µs instantiate. Both figures were the wrong side of the
+boundary. Measured through `cljwit.host` itself:
+
+| | µs per instantiate |
+|---|---:|
+| no imports | **56.9** |
+| one import | **73.2** |
+
+So an import costs **+16 µs on a 57 µs baseline** — stub, reflection and
+linker registration together — and the 20 µs came from a C probe, not from
+this library (see the correction in `0014` C).
+
+Reusing one linker across instantiates *does* work — wasmtime does not refuse
+it — and measured in C it saves **1.23–1.45×**, not the multiple the argument
+assumed. Against that, engine-scoped stubs need routing through the store data
+pointer to reach a per-instance Clojure function, and `0018`'s review showed
+that is exactly where destructor routing becomes hard.
+
+**So: per-instantiate, until a world with many *user* imports says otherwise.**
+WASI does not: `add_wasip2` supplies its interfaces without a stub each.
+Falsified by a component whose own imports number in the dozens, where 16 µs
+each would dominate.
 
 ### B. The host checks for *extra* imports, and lets wasmtime report missing ones