@polyengine/wasi 0.2.0-pre.g2125a06 → 0.3.0

package/esm/http.js

@@ -65,7 +65,7 @@
 // A10: case names are data, kebab-case as written, including capitals).
 // Fetch failures are TypeErrors with prose; a small sniff table maps the
 // recognizable ones and everything else is `internal-error(message)`.
-import { ComponentException } from "@polyengine/runtime/embedder";
+import { ComponentException, isComponentException } from "@polyengine/runtime/embedder";
 /**
  * The compatibility track the fragment registers on by default.
  *
@@ -679,7 +679,10 @@ export function http(options = {}) {
         }
         let resp;
         try {
-            resp = await fetch(url, {
+            // Constructing the `Request` happens inside this try: a throw here
+            // (e.g. a GET with a body) maps through mapFetchError exactly as a
+            // fetch throw does, per the same catch below.
+            const req = new globalThis.Request(url, {
                 method,
                 headers,
                 body: body === undefined || body.length === 0 ? undefined : body,
@@ -687,8 +690,20 @@ export function http(options = {}) {
                 cache: "no-store",
                 credentials: "omit",
             });
+            // Resolved at call time (not captured at http() construction), so
+            // a test stubbing globalThis.fetch after the fragment exists still
+            // takes effect.
+            const transport = options.fetch ?? ((r) => globalThis.fetch(r));
+            resp = await transport(req);
         }
         catch (e) {
+            if (isComponentException(e)) {
+                // Branded exception passthrough: the transport named the
+                // guest-visible WIT error-code itself; do not run it through
+                // mapFetchError's prose sniffing, and rethrow unchanged.
+                request.settleTransmission({ kind: "err", value: e.payload });
+                throw e;
+            }
             const code = mapFetchError(e);
             request.settleTransmission({ kind: "err", value: code });
             throw httpError(code, `client.send: ${e instanceof Error ? e.message : String(e)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polyengine/wasi",
-  "version": "0.2.0-pre.g2125a06",
+  "version": "0.3.0",
   "description": "WASI providers for polyengine hosts: the p2 baseline and p3 clocks, one module per semver track.",
   "homepage": "https://github.com/polymorph-components/polyengine#readme",
   "repository": {
@@ -91,8 +91,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@polyengine/protocol": "0.2.0-pre.g2125a06",
-    "@polyengine/runtime": "0.2.0-pre.g2125a06"
+    "@polyengine/protocol": "0.3.0",
+    "@polyengine/runtime": "0.3.0"
   },
   "_generatedBy": "dnt@0.43.2"
 }

package/types/http.d.ts

@@ -131,6 +131,32 @@ export interface HttpOptions {
         method: string;
         headers: Headers;
     }) => boolean | Promise<boolean>);
+    /**
+     * Injectable transport: replaces the `fetch(request)` call `client.send`
+     * otherwise makes directly. Default (when omitted): `globalThis.fetch`,
+     * resolved AT CALL TIME — not captured when `http()` constructs the
+     * fragment — so stubbing `globalThis.fetch` after the fragment exists
+     * still takes effect.
+     *
+     * The `Request` handed to the transport already carries this
+     * fragment's hardening (`redirect: "manual"`, `cache: "no-store"`,
+     * `credentials: "omit"`). A transport that forwards to the real
+     * `fetch` with its own `init` can override these — re-enabling
+     * redirect-following in particular would break the property that every
+     * redirect hop re-enters `send` and is re-checked by `allowRequest`.
+     * The transport is trusted embedder code; this is a caution, not a
+     * hole.
+     *
+     * `request.clone()` is how to inspect the body without consuming it,
+     * so a transport can peek (e.g. for logging) and still forward the
+     * original request.
+     *
+     * A transport that throws a branded `ComponentException` names the
+     * guest-visible WIT error-code exactly (the fragment rethrows it
+     * unchanged); anything else it throws is mapped by this fragment's
+     * `mapFetchError` sniffing, which usually lands on `internal-error`.
+     */
+    fetch?: (request: globalThis.Request) => Promise<globalThis.Response>;
 }
 /** What `http()` returns: the imports fragment plus the fragment's classes. */
 export interface HttpFragment {