@polyengine/wasi 0.2.0-pre.g20030fc → 0.2.0-pre.g2125a06

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, isComponentException } from "@polyengine/runtime/embedder";
+import { ComponentException } from "@polyengine/runtime/embedder";
 /**
  * The compatibility track the fragment registers on by default.
  *
@@ -679,10 +679,7 @@ export function http(options = {}) {
         }
         let resp;
         try {
-            // 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, {
+            resp = await fetch(url, {
                 method,
                 headers,
                 body: body === undefined || body.length === 0 ? undefined : body,
@@ -690,20 +687,8 @@ 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.g20030fc",
+  "version": "0.2.0-pre.g2125a06",
   "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.g20030fc",
-    "@polyengine/runtime": "0.2.0-pre.g20030fc"
+    "@polyengine/protocol": "0.2.0-pre.g2125a06",
+    "@polyengine/runtime": "0.2.0-pre.g2125a06"
   },
   "_generatedBy": "dnt@0.43.2"
 }

package/types/http.d.ts

@@ -131,32 +131,6 @@ 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 {