chore(jco): jco-std -> v0.3.0, jco-transpile -> v0.13.0

.github/workflows/main.yml

@@ -194,6 +194,10 @@ jobs:
           name: build-preview2-shim
           path: packages/preview2-shim/dist
 
+      # Temporarily exercise unpublished jco-std fixes through the workspace dependency.
+      - name: Build workspace jco-std
+        run: pnpm --filter '@bytecodealliance/jco-std' run build:ts
+
       - name: Test jco (node@lts)
         if: matrix.node != 'latest'
         working-directory: packages/jco

docs/src/interop/nodejs-builtins.md

@@ -801,6 +801,30 @@ clients and servers. `wasi-http` implements clients and rejects server
 construction immediately because outgoing-handler cannot listen for arbitrary
 connections.
 
+For direct servers, instantiate with a provider bound to that component's
+callback dispatcher. For example, after transpiling with
+`--instantiation async --map jco:node/http@0.1.0=http-host`:
+
+```js
+import { instantiate } from './component.js';
+import { WASIShim } from '@bytecodealliance/preview2-shim/instantiation';
+import { createHttpHost } from '@bytecodealliance/jco-std/wasi/0.2.x/node/24.x.x/http/host/node';
+
+let instance;
+const imports = new WASIShim().getImportObject();
+imports['http-host'] = createHttpHost(() => instance.httpCallbacks);
+instance = await instantiate(undefined, imports);
+// Await application exports that create or control servers.
+await instance.start();
+```
+
+Create a separate provider for each component instance. The server holds a
+callback registration ID; handlers stay in the guest and run through the
+exported dispatcher. The provider serializes callback entry and drains accepted
+callbacks before close completes. Closing releases the guest registration;
+listening again registers the same server's handler again. Direct client-only
+applications can continue mapping the Node provider module without this factory.
+
 > [!WARNING]
 > All modes currently buffer complete request and response bodies.
 

packages/jco-std/README.md

@@ -608,7 +608,10 @@ When the selected world is missing a required import or callback export, Jco
 edits that world in place, adds generated comments and declarations, installs
 the corresponding WIT packages under `wit/deps`, and prints a warning. Direct
 servers use an imported host-owned `server` resource plus an exported
-guest-owned request-listener resource. Jco re-bundles a small entry wrapper so
+callback dispatcher. Each server passes a guest registration ID to its host;
+the guest retains its handler while listening and releases it after close.
+Node hosts use `createHttpHost(() => instance.httpCallbacks)` from the opt-in
+provider to bind callbacks to one component instance. Jco re-bundles a small entry wrapper so
 the callback implementation is present on the final component export. Existing
 declarations and dependency files are preserved, aliases are recognized, and
 repeated componentization does not add duplicates. Use `--world-name` when the

packages/jco-std/package.json

@@ -114,6 +114,11 @@
       "browser": "./dist/wasi/0.2.x/node/24.x.x/http/core.js",
       "default": "./dist/wasi/0.2.x/node/24.x.x/http/core.js"
     },
+    "./wasi/0.2.x/node/24.x.x/http/impl/direct": {
+      "types": "./dist/wasi/0.2.x/node/24.x.x/http/impl/direct.d.ts",
+      "browser": "./dist/wasi/0.2.x/node/24.x.x/http/impl/direct.js",
+      "default": "./dist/wasi/0.2.x/node/24.x.x/http/impl/direct.js"
+    },
     "./wasi/0.2.x/node/24.x.x/http/impl/wasi-sockets": {
       "types": "./dist/wasi/0.2.x/node/24.x.x/http/impl/wasi-sockets.d.ts",
       "browser": "./dist/wasi/0.2.x/node/24.x.x/http/impl/wasi-sockets.js",

packages/jco-std/src/wasi/0.2.x/node/24.x.x/dns/core.ts

@@ -8,6 +8,8 @@
  * share state between callback and promise facades, and make cancellation explicit.
  */
 import { dnsError, invalidArgType, invalidArgValue, unsupported } from "./errors.js";
+import { callHost } from "../internal/host-error.js";
+import type { HostImports } from "../internal/wit-types.js";
 import type {
   AnyRecord,
   CaaRecord,
@@ -105,11 +107,8 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null;
 }
 
-function hostResult<T>(response: DnsResult<T>): T {
-  if (response.tag === "err") {
-    throw dnsError(response.val);
-  }
-  return response.val;
+function hostResult<T>(operation: () => T | DnsResult<T>): T {
+  return callHost(operation, dnsError);
 }
 
 function hostFamily(value: DnsFamily): DnsHostFamily {
@@ -332,7 +331,7 @@ function resolveOperation(rrtype: string): ResolveOperation {
 }
 
 function resolveHost(
-  host: DnsHost,
+  host: HostImports<DnsHost>,
   operation: ResolveOperation,
   hostname: string,
   ttl: boolean,
@@ -341,37 +340,37 @@ function resolveHost(
   const configuration = hostResolver(resolver);
   switch (operation) {
     case "resolve4": {
-      const records = hostResult(host.resolve4(hostname, ttl, configuration));
+      const records = hostResult(() => host.resolve4(hostname, ttl, configuration));
       return ttl ? records : records.map((record) => record.address);
     }
     case "resolve6": {
-      const records = hostResult(host.resolve6(hostname, ttl, configuration));
+      const records = hostResult(() => host.resolve6(hostname, ttl, configuration));
       return ttl ? records : records.map((record) => record.address);
     }
     case "resolveAny":
-      return hostResult(host.resolveAny(hostname, configuration)).map(anyRecord);
+      return hostResult(() => host.resolveAny(hostname, configuration)).map(anyRecord);
     case "resolveCaa":
-      return hostResult(host.resolveCaa(hostname, configuration));
+      return hostResult(() => host.resolveCaa(hostname, configuration));
     case "resolveCname":
-      return hostResult(host.resolveCname(hostname, configuration));
+      return hostResult(() => host.resolveCname(hostname, configuration));
     case "resolveMx":
-      return hostResult(host.resolveMx(hostname, configuration));
+      return hostResult(() => host.resolveMx(hostname, configuration));
     case "resolveNaptr":
-      return hostResult(host.resolveNaptr(hostname, configuration));
+      return hostResult(() => host.resolveNaptr(hostname, configuration));
     case "resolveNs":
-      return hostResult(host.resolveNs(hostname, configuration));
+      return hostResult(() => host.resolveNs(hostname, configuration));
     case "resolvePtr":
-      return hostResult(host.resolvePtr(hostname, configuration));
+      return hostResult(() => host.resolvePtr(hostname, configuration));
     case "resolveSoa":
-      return hostResult(host.resolveSoa(hostname, configuration));
+      return hostResult(() => host.resolveSoa(hostname, configuration));
     case "resolveSrv":
-      return hostResult(host.resolveSrv(hostname, configuration));
+      return hostResult(() => host.resolveSrv(hostname, configuration));
     case "resolveTlsa":
-      return hostResult(host.resolveTlsa(hostname, configuration)).map(tlsaRecord);
+      return hostResult(() => host.resolveTlsa(hostname, configuration)).map(tlsaRecord);
     case "resolveTxt":
-      return hostResult(host.resolveTxt(hostname, configuration));
+      return hostResult(() => host.resolveTxt(hostname, configuration));
     case "reverse":
-      return hostResult(host.reverse(hostname, configuration));
+      return hostResult(() => host.reverse(hostname, configuration));
   }
 }
 
@@ -496,19 +495,19 @@ export interface DnsModules {
   };
 }
 
-export function createDns(host: DnsHost): DnsModules {
+export function createDns(host: HostImports<DnsHost>): DnsModules {
   let defaultOrder: DnsResultOrder = "verbatim";
   let defaultServers: string[] | undefined;
 
   function servers(): string[] {
-    return (defaultServers ??= hostResult(host.getServers())).slice();
+    return (defaultServers ??= hostResult(() => host.getServers())).slice();
   }
 
   function setServers(serversValue: string[]): void {
     if (!Array.isArray(serversValue)) {
       throw invalidArgType("servers", "Array");
     }
-    const validated = hostResult(host.validateServers(serversValue));
+    const validated = hostResult(() => host.validateServers(serversValue));
     defaultServers = validated.slice();
   }
 
@@ -526,7 +525,7 @@ export function createDns(host: DnsHost): DnsModules {
     hostname: string,
     options: ParsedLookupOptions,
   ): LookupAddress | LookupAddress[] {
-    const addresses = hostResult(
+    const addresses = hostResult(() =>
       host.lookup(hostname, {
         family: hostFamily(options.family),
         hints: options.hints,
@@ -584,7 +583,7 @@ export function createDns(host: DnsHost): DnsModules {
       if (!Array.isArray(value)) {
         throw invalidArgType("servers", "Array");
       }
-      this.configuration.servers = hostResult(host.validateServers(value));
+      this.configuration.servers = hostResult(() => host.validateServers(value));
     }
 
     setLocalAddress(ipv4 = "0.0.0.0", ipv6 = "::0"): void {
@@ -839,7 +838,7 @@ export function createDns(host: DnsHost): DnsModules {
     let result: { hostname: string; service: string } | undefined;
     let error: DnsError | undefined;
     try {
-      result = hostResult(host.lookupService(address, numericPort));
+      result = hostResult(() => host.lookupService(address, numericPort));
     } catch (caught) {
       error = caught instanceof Error ? (caught as DnsError) : new Error(String(caught));
     }
@@ -909,7 +908,7 @@ export function createDns(host: DnsHost): DnsModules {
       if (!Number.isInteger(numericPort) || numericPort < 0 || numericPort > 65535) {
         throw invalidArgValue("port", port);
       }
-      return promiseCall(() => hostResult(host.lookupService(address, numericPort)));
+      return promiseCall(() => hostResult(() => host.lookupService(address, numericPort)));
     },
     resolve: promiseResolver.resolve.bind(promiseResolver),
     resolve4: promiseResolver.resolve4.bind(promiseResolver),