@pulse-compute/provider-fastly 1.0.0-beta.1 → 1.0.0-beta.11

package/src/javascript/target.js

@@ -14,6 +14,16 @@ const FASTLY_JAVASCRIPT_TARGET_DESCRIPTOR = normalizeJavascriptTargetDescriptor(
   crypto: defineCryptoTargetCapabilities({
     target: 'javascript',
     algorithms: [{
+      algorithm: 'HMAC-SHA256',
+      realization: 'runtime-builtin',
+      implemented: true,
+      status: 'implemented-jwt-sign'
+    }, {
+      algorithm: 'SHA-256',
+      realization: 'runtime-builtin',
+      implemented: true,
+      status: 'implemented-d1'
+    }, {
       algorithm: 'HS256',
       realization: 'runtime-builtin',
       implemented: true,
@@ -23,6 +33,11 @@ const FASTLY_JAVASCRIPT_TARGET_DESCRIPTOR = normalizeJavascriptTargetDescriptor(
       realization: 'runtime-builtin',
       implemented: true,
       status: 'implemented-h4'
+    }, {
+      algorithm: 'RS256',
+      realization: 'runtime-builtin',
+      implemented: true,
+      status: 'implemented-h4'
     }]
   }),
   capabilities: {
@@ -45,7 +60,7 @@ const FASTLY_JAVASCRIPT_TARGET_DESCRIPTOR = normalizeJavascriptTargetDescriptor(
       kv: true,
       parallel: true
     },
-    packages: ['pulse.assets', 'pulse.grip', 'pulse.jwt'],
+    packages: ['pulse.assets', 'pulse.crypto', 'pulse.grip', 'pulse.jwt'],
     restrictions: {
       fetch: 'origin-backend-map-or-dynamic-opt-in',
       kv: 'logical-store-map-required',
@@ -57,6 +72,7 @@ const FASTLY_JAVASCRIPT_TARGET_DESCRIPTOR = normalizeJavascriptTargetDescriptor(
     supported: true,
     default: 'info',
     levels: ['off', 'error', 'warn', 'info', 'debug'],
+    destinations: ['stdout', 'configured-named-endpoint'],
     destination: 'provider-owned',
     betaDefault: 'stdio-log-tail'
   },

package/src/javascript/test-runtime.js

@@ -331,6 +331,7 @@ async function executeFastlyJavascriptLocalRequest(application, request, options
     maxRequestBodyBytes: options.maxRequestBodyBytes ?? options.maxBodyBytes,
     maxFetchBodyBytes: options.maxFetchBodyBytes ?? options.maxBodyBytes,
     maxStructuredBodyBytes: options.maxStructuredBodyBytes,
+    binaryResources: options.binaryResources,
     schemaCodecs: options.schemaCodecs,
     strict: options.strict === true,
     reporting: options.reporting,

package/src/provider-contract.js

@@ -12,27 +12,41 @@ const FASTLY_PROVIDER_DESCRIPTOR = canonical.normalizeDescriptor({
   deployable: true,
   localExecution: true,
   capabilities: [
-    'request', 'response.json', 'response.text', 'response.custom', 'fetch',
-    'config.get', 'secret.get', 'kv.get', 'kv.put', 'assets.lookup',
-    'grip.channel', 'grip.hold', 'grip.publish', 'grip.broadcast', 'jwt.verify',
-    'opaque.pass-through'
+    'host.extension', 'request', 'request.body.forward', 'response.json', 'response.text', 'response.custom', 'fetch',
+    'time.wall-clock', 'crypto.digestText', 'config.get', 'secret.get', 'kv.get', 'kv.put', 'kv.getVersioned', 'kv.insertIfAbsent', 'kv.compareAndSwap', 'kv.list', 'kv.delete', 'assets.lookup',
+    'grip.channel', 'grip.hold', 'grip.publish', 'grip.broadcast', 'jwt.verify', 'jwt.sign',
+    'opaque.pass-through', 's3.head', 's3.getText', 's3.putText', 's3.getBody'
   ],
   lowering: {
+    'host.extension': 'fastly.native.terminal-request-backend.v1',
     request: 'fastly.compute.request',
+    'request.body.forward': 'fastly.native.body-forwarding',
     'response.json': 'fastly.compute.response.json',
     'response.text': 'fastly.compute.response.text',
     'response.custom': 'fastly.compute.response.custom',
     fetch: 'fastly.backend.fetch',
+    'time.wall-clock': 'wasi.clock_time_get.realtime',
+    'crypto.digestText': 'pulse.crypto.guest-source.sha256',
     'config.get': 'fastly.config-store.get',
     'secret.get': 'fastly.secret-store.get',
     'kv.get': 'fastly.kv-store.get',
     'kv.put': 'fastly.kv-store.put',
+    'kv.list': 'fastly.native.kv-store.list',
+    'kv.delete': 'fastly.native.kv-store.delete',
+    'kv.getVersioned': 'fastly.native.kv-store.getVersioned',
+    'kv.insertIfAbsent': 'fastly.native.kv-store.insertIfAbsent',
+    'kv.compareAndSwap': 'fastly.native.kv-store.compareAndSwap',
     'assets.lookup': 'fastly.kv-store.assets.lookup',
     'grip.channel': 'fastly.fanout.channel',
     'grip.hold': 'fastly.fanout.hold',
     'grip.publish': 'fastly.fanout.publish',
     'grip.broadcast': 'fastly.grip.publish-control',
     'jwt.verify': 'fastly.native.jwt.verify',
+    'jwt.sign': 'fastly.native.jwt.sign',
+    's3.head': 'fastly.native.s3.head',
+    's3.getText': 'fastly.native.s3.getText',
+    's3.getBody': 'fastly.native.s3.getBody',
+    's3.putText': 'fastly.native.s3.putText',
     'opaque.pass-through': 'fastly.response-body.stream'
   }
 });
@@ -52,9 +66,12 @@ function validateStaticBackendBindings(metadata = {}, bindings = {}) {
   }
 }
 
-function createFastlyLoweringPlan(metadata, bindings = {}) {
+function createFastlyLoweringPlan(metadata, bindings = {}, options = {}) {
+  const forwarding = require('./toolchain/body-forwarding.js').normalizeBodyForwarding(options.bodyForwarding, options.maxDurationMs);
+  const descriptor = forwarding ? FASTLY_PROVIDER_DESCRIPTOR : {...FASTLY_PROVIDER_DESCRIPTOR, capabilities: FASTLY_PROVIDER_DESCRIPTOR.capabilities.filter(id => id !== 'request.body.forward')};
+  require('./toolchain/s3.js').resolveFastlyS3(metadata.providerOperations || [], bindings.s3);
   validateStaticBackendBindings(metadata, bindings);
-  return canonical.createProviderLoweringPlan(metadata, FASTLY_PROVIDER_DESCRIPTOR, {
+  return canonical.createProviderLoweringPlan(metadata, descriptor, {
     ...bindings,
     grip: bindings.grip || 'fastly-fanout'
   });

package/src/runtime/canonical-api-runtime.js

@@ -337,9 +337,15 @@ function createFastlyProviderAdapter(baseOptions = {}) {
   return Object.freeze({
     id: 'fastly',
     version: CANONICAL_FASTLY_RUNTIME_VERSION,
+    // This legacy JavaScript fixture surface has no Native KV host ABI. Keep
+    // that absence pre-dispatch/configuration, rather than pretending a failed
+    // fixture dispatch might have mutated storage. Real K3 evidence runs Wasm.
+    prepareConditionalKv() { return undefined; },
     async dispatchEffect(effect, executionOptions = {}) {
       const state = stateFor(executionOptions);
       if (effect.kind === 'fetch') return dispatchFetch(effect, executionOptions);
+      if (effect.kind === 'crypto.digestText') return require('@pulse-compute/crypto/provider').createJavascriptTextDigest(baseOptions)(effect, executionOptions);
+      if (effect.kind === 'time.now') return require('@pulse-compute/runtime/host').readWallTime(baseOptions.wallClock === undefined ? () => Date.now() : baseOptions.wallClock);
       if (effect.kind === 'config.get') return state.surface.config.adapter.get(effect.name);
       if (effect.kind === 'secret.get') {
         const secret = state.surface.secret.adapter.get(effect.name);

package/src/testing/conditional-kv-host.js

@@ -0,0 +1,155 @@
+'use strict';
+
+// Injected ABI authority for real generated Wasm evidence, never a service adapter.
+// Raw persisted bytes and u64 generations remain independent of the Pulse codec.
+function createConditionalKvAuthority() {
+  const stores = new Map(); let next = 1n;
+  return {
+    stores,
+    seed(store, key, wire, generation = next++) {
+      if (!stores.has(store)) stores.set(store, new Map());
+      stores.get(store).set(key, { wire: Buffer.from(wire), generation: BigInt(generation) });
+    },
+    get(store, key) { return stores.get(store)?.get(key); },
+    delete(store, key) { return stores.get(store).delete(key) ? 1 : 3; },
+    list(store, { limit, prefix = '', cursor }) {
+      // Test authority models a live ordered page independently of Pulse's parser.
+      let after;
+      if (cursor !== undefined) {
+        if (!/^abi-kv:/.test(cursor)) return { code: 2 };
+        try { const token = JSON.parse(Buffer.from(cursor.slice(7), 'base64url')); if (token.store !== store || token.prefix !== prefix || typeof token.after !== 'string') return { code: 2 }; after = token.after; }
+        catch (_) { return { code: 2 }; }
+      }
+      const all = [...stores.get(store).keys()].sort((a,b) => Buffer.compare(Buffer.from(a),Buffer.from(b))).filter(key => key.startsWith(prefix) && (after === undefined || Buffer.compare(Buffer.from(key), Buffer.from(after)) > 0));
+      const data = all.slice(0, limit), meta = { limit, ...(prefix ? { prefix } : {}) };
+      if (all.length > limit) meta.next_cursor = 'abi-kv:' + Buffer.from(JSON.stringify({ store, prefix, after: data[data.length - 1] })).toString('base64url');
+      return { code: 1, wire: Buffer.from(JSON.stringify({ data, meta })) };
+    },
+    apply(store, key, wire, mode, condition) {
+      const values = stores.get(store), current = values.get(key);
+      if (mode === 1 && current || condition !== undefined && (!current || current.generation !== condition)) return 4;
+      while (next === current?.generation) next++;
+      this.seed(store, key, wire, next++); return 1;
+    }
+  };
+}
+
+function attachConditionalKvHost(imports, host, options) {
+  const { view, writeU32, writeU64, readBytes, readUtf8, alloc, bodies, bodyBytes, trace, now, advance } = host;
+  const authority = options.authority, stores = new Map(), pending = new Map(), bodyFixtures = new Map();
+  let sendingResponse = false;
+  const newResponse = imports.fastly_http_resp.new;
+  imports.fastly_http_resp.new = (...args) => { sendingResponse = true; return newResponse(...args); };
+  const call = (stage, detail = {}) => {
+    const fault = typeof options.onCall === 'function' ? options.onCall(stage, detail) || {} : {};
+    advance(Number(fault.delayMs || 0));
+    trace.push({ module: 'pulse_kv_evidence', name: stage, hostStatus: fault.status ?? 0, ...(fault.kvError === undefined ? {} : { kvError: fault.kvError }) });
+    return fault;
+  };
+  imports.fastly_kv_store = {
+    open(ptr, len, out) {
+      const name = readUtf8(ptr, len), fault = call('open', { store: name });
+      if (fault.status) return fault.status;
+      if (!authority.stores.has(name)) return 10;
+      const handle = alloc('kvStore'); stores.set(handle, name); writeU32(out, handle); return 0;
+    },
+    lookup(store, ptr, len, mask, config, out) {
+      const name = stores.get(store), key = readUtf8(ptr, len), fault = call('lookup', { store: name, key, mask, config: readBytes(config, 4) });
+      if (fault.status) return fault.status;
+      const item = fault.observation || authority.get(name, key);
+      const handle = alloc('kvLookup'); pending.set(handle, { kind: 'lookup', item, readyAt: now() + Number(fault.readyDelayMs || 0), fault });
+      writeU32(out, handle); return 0;
+    },
+    lookup_wait_v2(handle, body, meta, capacity, written, generation, error) {
+      const item = pending.get(handle); if (!item || item.readyAt > now()) throw new Error('KV lookup wait called before readiness.');
+      pending.delete(handle); const fault = call('lookup_wait_v2', { capacity, observation: item.item });
+      writeU32(error, fault.kvError ?? (item.item ? 1 : 3)); writeU64(generation, fault.generation ?? item.item?.generation ?? 0n);
+      writeU32(written, fault.metadataLength ?? 0);
+      if (fault.status) return fault.status;
+      if ((fault.kvError ?? (item.item ? 1 : 3)) !== 1) return 0;
+      const handleOut = alloc('body'); const bytes = Buffer.from(fault.wire || item.item.wire);
+      bodies.set(handleOut, { bytes, readOffset: 0, writes: [], readyAt: now() + Number(fault.bodyDelayMs || 0) });
+      bodyFixtures.set(handleOut, fault); writeU32(body, handleOut); return 0;
+    },
+    insert(store, ptr, len, body, mask, config, out) {
+      const name = stores.get(store), key = readUtf8(ptr, len), wire = Buffer.from(bodyBytes(body));
+      const mode = view().getUint32(config, true), condition = mask & 32 ? view().getBigUint64(config + 24, true) : undefined;
+      const fault = call('insert', { store: name, key, wire, mode, mask, condition, config: readBytes(config, 32) });
+      let code = fault.kvError;
+      if (code === undefined && (!fault.status || fault.commit)) code = authority.apply(name, key, wire, mode, condition);
+      bodies.delete(body); // Host takes ownership of the body.
+      if (fault.status) return fault.status;
+      const handle = alloc('kvInsert'); pending.set(handle, { kind: 'insert', code, readyAt: now() + Number(fault.readyDelayMs || 0) });
+      writeU32(out, handle); return 0;
+    },
+    delete(store, ptr, len, mask, config, out) {
+      if (mask !== 0 || view().getUint32(config, true) !== 0) throw new Error('KV delete config must be empty.');
+      const name = stores.get(store), key = readUtf8(ptr, len), fault = call('delete', { store: name, key, mask });
+      const code = fault.kvError ?? ((!fault.status || fault.commit) ? authority.delete(name, key) : undefined);
+      if (fault.status) return fault.status;
+      const handle = alloc('kvDelete'); pending.set(handle, { kind: 'delete', code, readyAt: now() + Number(fault.readyDelayMs || 0) });
+      writeU32(out, handle); return 0;
+    },
+    delete_wait(handle, error) {
+      const item = pending.get(handle); if (!item || item.kind !== 'delete' || item.readyAt > now()) throw new Error('KV delete wait called before readiness.');
+      pending.delete(handle); const fault = call('delete_wait'); writeU32(error, fault.kvError ?? item.code ?? 0); return fault.status ?? 0;
+    },
+    list(store, mask, config, out) {
+      if ((mask & ~14) !== 0 || !(mask & 4) || view().getUint32(config, true) !== 0) throw new Error('KV list requires bounded strong mode.');
+      const cursor = mask & 2 ? readUtf8(view().getUint32(config + 4, true), view().getUint32(config + 8, true)) : undefined;
+      const limit = view().getUint32(config + 12, true);
+      const prefix = mask & 8 ? readUtf8(view().getUint32(config + 16, true), view().getUint32(config + 20, true)) : '';
+      if (limit < 1 || limit > 100 || cursor === '' || mask & 8 && !prefix) throw new Error('KV list config is invalid.');
+      const name = stores.get(store), fault = call('list', { store: name, mask, limit, prefix, cursor });
+      if (fault.status) return fault.status;
+      const result = authority.list(name, { limit, prefix, cursor });
+      const handle = alloc('kvList'); pending.set(handle, { kind: 'list', ...result, readyAt: now() + Number(fault.readyDelayMs || 0) });
+      writeU32(out, handle); return 0;
+    },
+    list_wait(handle, body, error) {
+      const item = pending.get(handle); if (!item || item.kind !== 'list' || item.readyAt > now()) throw new Error('KV list wait called before readiness.');
+      pending.delete(handle); const fault = call('list_wait'); writeU32(error, fault.kvError ?? item.code);
+      if (fault.status) return fault.status;
+      if ((fault.kvError ?? item.code) !== 1) return 0;
+      const bodyHandle = alloc('body'); bodies.set(bodyHandle, { bytes: Buffer.from(fault.wire ?? item.wire), readOffset: 0, writes: [], readyAt: now() + Number(fault.bodyDelayMs || 0) });
+      bodyFixtures.set(bodyHandle, fault); writeU32(body, bodyHandle); return 0;
+    },
+    insert_wait(handle, error) {
+      const item = pending.get(handle); if (!item || item.readyAt > now()) throw new Error('KV insert wait called before readiness.');
+      pending.delete(handle); const fault = call('insert_wait'); writeU32(error, fault.kvError ?? item.code ?? 0); return fault.status ?? 0;
+    }
+  };
+  const select = imports.fastly_async_io.select;
+  imports.fastly_async_io.select = (handles, count, timeout, done) => {
+    const handle = view().getUint32(handles, true), item = pending.get(handle) || (bodyFixtures.has(handle) && bodies.get(handle));
+    if (!item) return select(handles, count, timeout, done);
+    if (count !== 1 || timeout <= 0) throw new Error('KV select must be bounded.');
+    const fault = call('select', { kind: item.kind || 'body', timeout });
+    if (fault.status) return fault.status;
+    const wait = Math.max(0, item.readyAt - now()); advance(Math.min(wait, timeout));
+    writeU32(done, fault.readyIndex ?? (wait >= timeout ? 0xffffffff : 0)); return 0;
+  };
+  for (const name of ['new', 'write', 'read', 'close']) {
+    const original = imports.fastly_http_body[name];
+    imports.fastly_http_body[name] = (...args) => {
+      const [handle] = args;
+      if (sendingResponse) return original(...args);
+      if (name === 'read' && !bodyFixtures.has(handle)) return original(...args);
+      const fault = call('body_' + name, { handle });
+      if (fault.status) return fault.status;
+      const result = original(...args);
+      if (name === 'read') {
+        const fixture = bodyFixtures.get(handle), body = bodies.get(handle);
+        if (body) body.readyAt = now() + Number(fixture.chunkDelayMs || 0);
+        if (fault.written !== undefined) writeU32(args[3], fault.written);
+      }
+      if (name === 'write' && fault.written !== undefined) writeU32(args[4], fault.written);
+      if (name === 'close') bodyFixtures.delete(handle);
+      return result;
+    };
+  }
+  const clock = imports.wasi_snapshot_preview1.clock_time_get;
+  imports.wasi_snapshot_preview1.clock_time_get = (...args) => { const fault = call('clock'); return fault.status || clock(...args); };
+  return { pending, bodyFixtures };
+}
+module.exports = { createConditionalKvAuthority, attachConditionalKvHost };

package/src/testing/native-dynamic-backends-host.js

@@ -0,0 +1,39 @@
+'use strict';
+
+// Independent ABI oracle shared by the two injected Fastly hosts. This is test
+// infrastructure, not a network implementation or a hosted capability probe.
+const assert = require('node:assert/strict');
+function createDynamicBackendHost({ view, readUtf8, trace, options, beforeRegister = () => {} }) {
+  const backends = new Map();
+  function register(np, nl, tp, tl, mask, config) {
+    beforeRegister();
+    assert.equal(config % 4, 0);
+    const words = Array.from({ length: 27 }, (_, i) => view().getUint32(config + i * 4, true));
+    const text = i => readUtf8(words[i], words[i + 1]);
+    const name = readUtf8(np, nl), target = readUtf8(tp, tl), host = text(0);
+    const tls = (mask & 32) !== 0;
+    assert.equal(mask, tls ? 2338 : 2, 'Only Host and URL-derived TLS settings are enabled');
+    const used = new Set(tls ? [0, 1, 7, 8, 13, 14] : [0, 1]);
+    words.forEach((word, i) => { if (!used.has(i)) assert.equal(word, 0, 'Unused ABI field ' + i); });
+    const record = { name, target, host, tls, certificateHostname: tls ? text(7) : '', sni: tls ? text(13) : '' };
+    if (tls) assert.equal(record.certificateHostname, record.sni);
+    let status = Number(options.dynamicBackendStatus || 0);
+    if (typeof options.onDynamicBackendRegistration === 'function') status = options.onDynamicBackendRegistration(record) ?? status;
+    if (backends.has(name) || (options.staticBackendNames || []).includes(name)) status = 1;
+    if (!status) backends.set(name, record);
+    trace.push({ ...record, module: 'fastly_http_req', backendName: name, name: 'register_dynamic_backend', status });
+    return status;
+  }
+  function route(name, request) {
+    const backend = backends.get(name);
+    if (!backend) return; // Statically configured names retain fixture routing.
+    const url = new URL(request.url);
+    assert.equal(backend.target, url.hostname + ':' + (url.port || (url.protocol === 'https:' ? '443' : '80')));
+    assert.equal(backend.tls, url.protocol === 'https:');
+    if (backend.tls) assert.equal(backend.sni, url.hostname);
+    request.headers = request.headers.filter(([key]) => key.toLowerCase() !== 'host');
+    request.headers.push(['host', backend.host]);
+  }
+  return { register, route };
+}
+module.exports = { createDynamicBackendHost };

package/src/testing/native-http-effects-host.js

@@ -80,6 +80,7 @@ function executeFastlyNativeHttpEffects(input, options = {}) {
   const bodies = new Map();
   const responses = new Map();
   const pending = new Map();
+  const outboundRequests = [];
   const downstreamRequestHandle = 1;
   const downstreamBodyHandle = 2;
   requests.set(downstreamRequestHandle, { method, url, headers: requestHeaders.map((entry) => [...entry]) });
@@ -111,6 +112,8 @@ function executeFastlyNativeHttpEffects(input, options = {}) {
   function readBytes(pointer, length) { return Buffer.from(new Uint8Array(memory().buffer, Number(pointer), Number(length))); }
   function readUtf8(pointer, length) { return readBytes(pointer, length).toString('utf8'); }
 
+  const dynamicBackends = require('./native-dynamic-backends-host.js').createDynamicBackendHost({ view, readUtf8, trace, options });
+
   function writeUtf8(value, pointer, maxLength, writtenOut) {
     const bytes = Buffer.from(String(value), 'utf8');
     writeU32(writtenOut, bytes.length);
@@ -164,6 +167,7 @@ function executeFastlyNativeHttpEffects(input, options = {}) {
       }
     },
     fastly_http_req: {
+      register_dynamic_backend: dynamicBackends.register,
       body_downstream_get(requestOut, bodyOut) {
         trace.push({ module: 'fastly_http_req', name: 'body_downstream_get' });
         writeU32(requestOut, downstreamRequestHandle);
@@ -219,18 +223,30 @@ function executeFastlyNativeHttpEffects(input, options = {}) {
         trace.push({ module: 'fastly_http_req', name: 'header_insert', handle: Number(handle), header: [name, value] });
         return FASTLY_STATUS_OK;
       },
+      header_append(handle, namePointer, nameLength, valuePointer, valueLength) {
+        const request = requests.get(Number(handle));
+        if (!request) return FASTLY_STATUS_BADF;
+        const name = readUtf8(namePointer, nameLength);
+        const value = readUtf8(valuePointer, valueLength);
+        request.headers.push([name, value]);
+        trace.push({ module: 'fastly_http_req', name: 'header_append', handle: Number(handle), header: [name, value] });
+        return FASTLY_STATUS_OK;
+      },
       send_async(handle, bodyHandle, backendPointer, backendLength, pendingOut) {
         const request = requests.get(Number(handle));
         const body = bodies.get(Number(bodyHandle));
         if (!request || !body) return FASTLY_STATUS_BADF;
         const backend = readUtf8(backendPointer, backendLength);
+        dynamicBackends.route(backend, request);
         const fixture = resolveFixture(options.fixtures, backend, request.method, request.url);
         if (!fixture) {
           trace.push({ module: 'fastly_http_req', name: 'send_async', handle: Number(handle), backend, method: request.method, url: request.url, missingFixture: true });
           return FASTLY_STATUS_ERROR;
         }
         const pendingHandle = alloc('pending');
-        pending.set(pendingHandle, { request: { ...request, headers: request.headers.map((entry) => [...entry]), body: bodyBytes(bodyHandle) }, backend, fixture });
+        const outbound = { ...request, headers: request.headers.map((entry) => [...entry]), body: bodyBytes(bodyHandle) };
+        outboundRequests.push(outbound);
+        pending.set(pendingHandle, { request: outbound, backend, fixture });
         writeU32(pendingOut, pendingHandle);
         trace.push({ module: 'fastly_http_req', name: 'send_async', handle: Number(handle), bodyHandle: Number(bodyHandle), pendingHandle, backend, method: request.method, url: request.url });
         return FASTLY_STATUS_OK;
@@ -373,6 +389,7 @@ function executeFastlyNativeHttpEffects(input, options = {}) {
       bodyHandle: downstream.bodyHandle
     }),
     trace: Object.freeze(trace.map((entry) => Object.freeze({ ...entry }))),
+    outboundRequests: Object.freeze(outboundRequests.map(entry => Object.freeze(entry))),
     instance
   });
 }