Clarify the scope of stdin/stdout for dynamically linked modules

[bep]

See https://github.com/bep/javywazeroissue/blob/58a6147e45096a2dbfc4d106002898c8f960b677/lib.go#L43

I'm pasting the relevant lines here for discussion:

buff := &bytes.Buffer{}
buff.WriteString(`{ "n": 2, "bar": "baz" }`)

_, err = r.InstantiateModule(ctx, compiledQuickJS, wazero.NewModuleConfig().WithStdout(buff).WithStderr(os.Stderr).WithStdin(buff).WithName("javy_quickjs_provider_v2"))
if err != nil {
	return "", err
}

_, err = r.InstantiateModule(ctx, compiledFoo, wazero.NewModuleConfig().WithName("foo"))
if err != nil {
	return "", err
}

fmt.Println(buff.String()) // Output: {"foo":3,"newBar":"baz!"}

The above works and is more or less the "hello world" example from https://github.com/bytecodealliance/javy.

To me, the foo module is the running instance, yet it uses stdin/stdout from the dynamically linked module, which I find surprising, and makes it impossible to init multiple JS modules (either different modules, or multiple instances of the same) in the same runtime.

I have implemented a proof of concept on this for inclusion in Hugo, with a simple RPC dispatcher over stdin/stdout, and it mostly works great. But for slower running scripts (e.g. Katex), I would want to have multiple instances of the script.¹ And with the above, I need to create a new runtime per instance (with a shared compilation cache). This works, but is resource heavy:

BenchmarkKatexStartStop/PoolSize1-10         	      61	  18518154 ns/op	12242519 B/op	   18054 allocs/op
BenchmarkKatexStartStop/PoolSize8-10         	       9	 117701093 ns/op	97889447 B/op	  144385 allocs/op
BenchmarkKatexStartStop/PoolSize16-10        	       5	 222097958 ns/op	195748028 B/op	  288710 allocs/op

Ideally I would want to do something ala:

_, err = r.InstantiateModule(ctx, compiledQuickJS, wazero.NewModuleConfig().WithName("javy_quickjs_provider_v2"))
if err != nil {
	return "", err
}

_, err = r.InstantiateModule(ctx, compiledFoo, wazero.NewModuleConfig().WithStdout(buff1).WithStderr(os.Stderr).WithStdin(buff1).WithName("foo1"))
if err != nil {
	return "", err
}
_, err = r.InstantiateModule(ctx, compiledFoo, wazero.NewModuleConfig().WithStdout(buff2).WithStderr(os.Stderr).WithStdin(buff2).WithName("foo2"))
if err != nil {
	return "", err
}
// ...

Footnotes

1. Yes, I have looked at https://github.com/suborbital/javy and https://github.com/F21/javy-wazero, but the bytecodealliance/Shopify fork seems to be the active one, and I don't think the suborbital fork would help with the main problem above. ↩

[bep]

Looking at my own writing above, I see that I need to do a little investigation to see how this is wired up at the Javy side, but I'll keep this open and I welcome any tips.

[bep]

I have done some investigating, and I'm guess the current behaviour is as expected with the current API: The executing function gets the fs/stdin/etc. from the module it's invoked.

What could possibly work and be worth while would be something ala:

RegisterModule(name, compiled)

Which when requested as an import, and not found in the regular instance map, would be instansiated with most of the config inherited from the importer.