@pulse-compute/provider-fastly 1.0.0-beta.7 → 1.0.0-beta.9

package/src/index.ts

@@ -1,3 +1,4 @@
+const { normalizeBodyForwarding } = require('../src/toolchain/body-forwarding.js') as { normalizeBodyForwarding(value: PulseFastlyBodyForwardingOptions | undefined, maxDurationMs?: number): PulseFastlyBodyForwardingOptions | undefined };
 const { normalizeFastlyMaxWasmBytes } = require('../src/build/wasm-budget.js') as { normalizeFastlyMaxWasmBytes(value?: number): number };
 const { normalizeRequestDuration } = require('@pulse-compute/runtime/host') as { normalizeRequestDuration(value?: number): number | undefined };
 import FASTLY_CONFIG_SCHEMA from './config-schema.json';
@@ -24,10 +25,17 @@ export interface PulseFastlyLocalOptions {
   readonly networkFetch?: boolean;
 }
 
+export interface PulseFastlyBodyForwardingOptions {
+  readonly requestMaxBytes: number;
+  readonly responseMaxBytes: number;
+}
+
 export interface PulseFastlyProviderOptions {
   /** Inclusive final Native Wasm byte budget; default 4 MiB. */
   readonly maxWasmBytes?: number;
   readonly maxDurationMs?: number;
+  /** Experimental Native metered pump; final close hands delivery to Fastly. */
+  readonly bodyForwarding?: PulseFastlyBodyForwardingOptions;
   readonly configStore?: string;
   readonly secretStore?: string;
   readonly kv?: Readonly<Record<string, string>>;
@@ -42,6 +50,8 @@ export interface PulseFastlyProviderOptions {
 
 export interface PulseFastlyProviderConfig {
   readonly maxDurationMs?: number;
+  /** Experimental Native metered pump; final close hands delivery to Fastly. */
+  readonly bodyForwarding?: PulseFastlyBodyForwardingOptions;
   readonly kind: 'fastly';
   readonly version: typeof FASTLY_PROVIDER_API_VERSION;
   readonly bindings: {
@@ -105,6 +115,7 @@ export function fastly(options: PulseFastlyProviderOptions = {}): PulseFastlyPro
   return Object.freeze({
     kind: 'fastly',
     maxDurationMs: normalizeRequestDuration(options.maxDurationMs),
+    bodyForwarding: normalizeBodyForwarding(options.bodyForwarding, options.maxDurationMs),
     version: FASTLY_PROVIDER_API_VERSION,
     bindings: Object.freeze({
       configStore: String(options.configStore ?? fastlyDefaults['fastly.configStore']),

package/src/provider-contract.js

@@ -12,13 +12,14 @@ const FASTLY_PROVIDER_DESCRIPTOR = canonical.normalizeDescriptor({
   deployable: true,
   localExecution: true,
   capabilities: [
-    'request', 'response.json', 'response.text', 'response.custom', 'fetch',
+    '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', '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: {
     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',
@@ -62,10 +63,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/testing/native-platform-capabilities-host.js

@@ -4,6 +4,7 @@ const fs = require('node:fs');
 const path = require('node:path');
 
 const FASTLY_STATUS_OK = 0;
+const FASTLY_STATUS_INVALID_ARGUMENT = 2;
 const FASTLY_STATUS_ERROR = 1;
 const FASTLY_STATUS_BADF = 3;
 const FASTLY_STATUS_BUFLEN = 4;
@@ -229,7 +230,7 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
     new Uint8Array(memory().buffer, Number(buffer), output.length).set(output);
     return FASTLY_STATUS_OK;
   }
-  function requestHeaderList(values, buffer, size, cursor, end, written, kind) {
+  function requestHeaderList(values, buffer, size, cursor, end, written, kind, lookupKind) {
     const limit = Math.min(Number(size), options.requestHeaderPageBytes ?? Number(size));
     let index = Number(cursor), count = 0;
     if (index < 0 || index > values.length) return FASTLY_STATUS_ERROR;
@@ -245,7 +246,7 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
     writeU32(written, count);
     view().setBigInt64(Number(end), index === values.length ? -1n : BigInt(index), true);
     // Fault injection is host-fixture-only; neither values nor faults enter traces.
-    const fault = options.requestHeaderFault?.({kind, cursor: Number(cursor)});
+    const fault = (lookupKind && options.headerLookupFault?.({kind:lookupKind})) || options.requestHeaderFault?.({kind, cursor: Number(cursor)});
     if (fault?.written !== undefined) writeU32(written, fault.written);
     if (fault?.cursor !== undefined) view().setBigInt64(Number(end), BigInt(fault.cursor), true);
     if (fault?.unterminated && count) new Uint8Array(memory().buffer)[Number(buffer) + count - 1] = 65;
@@ -253,19 +254,52 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
   }
   const imports = {
     fastly_async_io: {
-      select(handles, count, timeout, done) {
-        if (Number(count) !== 1 || Number(timeout) <= 0) return FASTLY_STATUS_ERROR;
-        const handle = view().getUint32(Number(handles), true);
-        const item = pending.get(handle) || bodies.get(handle);
+      is_ready(handle, out) {
+        const item = pending.get(Number(handle)) || bodies.get(Number(handle));
         if (!item) return FASTLY_STATUS_BADF;
-        const wait = Math.max(0, Number(item.readyAt || 0) - monotonicMs);
-        monotonicMs += Math.min(wait, Number(timeout));
-        writeU32(done, wait >= Number(timeout) ? 0xffffffff : 0);
-        trace.push({ module: 'fastly_async_io', name: 'select', timeout: Number(timeout), timedOut: wait >= Number(timeout) });
+        const ready = monotonicMs >= (item.readyAt || 0) ? 1 : 0;
+        writeU32(out, ready);
+        trace.push({module:'fastly_async_io',name:'is_ready',handle:Number(handle),ready,now:monotonicMs});
+        return FASTLY_STATUS_OK;
+      },
+      select(handles, count, timeout, done) {
+        if (Number(count) < 1 || Number(timeout) <= 0) return FASTLY_STATUS_ERROR;
+        const selected = Array.from({length:Number(count)},(_,i) => view().getUint32(Number(handles)+4*i,true));
+        const items = selected.map(handle => pending.get(handle) || bodies.get(handle));
+        if (items.some(item => !item)) return FASTLY_STATUS_BADF;
+        const waits = items.map(item => Math.max(0, Number(item.readyAt || 0) - monotonicMs));
+        const wait = Math.min(...waits), timedOut = wait >= Number(timeout);
+        const fault = options.asyncSelectFault?.({handles:selected,timeout:Number(timeout),now:monotonicMs});
+        monotonicMs += fault?.advanceMs ?? Math.min(wait,Number(timeout));
+        writeU32(done, fault?.selected ?? (timedOut ? 0xffffffff : waits.indexOf(wait)));
+        trace.push({ module: 'fastly_async_io', name: 'select', handles:selected, timeout:Number(timeout), timedOut, now:monotonicMs });
+        if (fault?.status) return fault.status;
         return FASTLY_STATUS_OK;
       }
     },
     wasi_snapshot_preview1: {
+      fd_write(fd, iovs, count, writtenOut) {
+        // WASI errno values, independent of the Fastly status enum.
+        if (Number(fd) !== 1) return 8; // BADF
+        if (options.logWriteFailure === true) {
+          trace.push({ module: 'wasi_snapshot_preview1', name: 'fd_write', fd: 1, accepted: false });
+          return 29; // IO
+        }
+        const chunks = [];
+        for (let index = 0; index < Number(count); index++) {
+          const pointer = Number(iovs) + index * 8;
+          chunks.push(readBytes(view().getUint32(pointer, true), view().getUint32(pointer + 4, true)));
+        }
+        const bytes = Buffer.concat(chunks);
+        const written = Math.min(bytes.length, options.logWriteMaxBytes ?? bytes.length);
+        const emitted = bytes.subarray(0, written).toString('utf8');
+        if (typeof options.onLogWrite === 'function') options.onLogWrite(emitted);
+        const message = redactText(emitted);
+        writeU32(writtenOut, written);
+        logs.push(Object.freeze({ endpoint: 'stdout', message }));
+        trace.push({ module: 'wasi_snapshot_preview1', name: 'fd_write', fd: 1, count: Number(count), bytes: bytes.length, written, message, accepted: true });
+        return 0;
+      },
       clock_time_get(clockId, precision, timeOut) {
         if (Number(clockId) === 1 && typeof options.monotonicClock === 'function') {
           const sample = options.monotonicClock(monotonicMs);
@@ -308,6 +342,11 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
     fastly_log: {
       endpoint_get(namePointer, nameLength, handleOut) {
         const endpoint = readUtf8(namePointer, nameLength);
+        // Match Viceroy/Compute: these names belong to stdio or the platform.
+        if (/^(?:stdout$|stderr$|fst_managed_)/i.test(endpoint)) {
+          trace.push({ module: 'fastly_log', name: 'endpoint_get', endpoint, opened: false });
+          return FASTLY_STATUS_INVALID_ARGUMENT;
+        }
         if (options.logEndpointFailure === true) {
           trace.push({ module: 'fastly_log', name: 'endpoint_get', endpoint, opened: false });
           return FASTLY_STATUS_ERROR;
@@ -325,7 +364,11 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
           trace.push({ module: 'fastly_log', name: 'write', endpoint, accepted: false });
           return FASTLY_STATUS_ERROR;
         }
-        const message = redactText(readUtf8(messagePointer, messageLength));
+        const emitted = readUtf8(messagePointer, messageLength);
+        // Test-only assertion seam before proof-trace redaction. Never retain raw
+        // guest bytes in the returned evidence, even when the guest regresses.
+        if (typeof options.onLogWrite === 'function') options.onLogWrite(emitted);
+        const message = redactText(emitted);
         writeU32(writtenOut, Buffer.byteLength(message));
         logs.push(Object.freeze({ endpoint, message }));
         trace.push({ module: 'fastly_log', name: 'write', endpoint, message, accepted: true });
@@ -360,7 +403,8 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
         const request = requests.get(Number(handle));
         if (!request) return FASTLY_STATUS_BADF;
         const name = readUtf8(pointer, length).toLowerCase();
-        return requestHeaderList(request.headers.filter(([key]) => key.toLowerCase() === name).map(([, value]) => value), buffer, size, cursor, end, written, 'values');
+        if (!/^[!#$%&'*+.^_`|~0-9a-z-]+$/.test(name)) return FASTLY_STATUS_INVALID_ARGUMENT;
+        return requestHeaderList(request.headers.filter(([key]) => key.toLowerCase() === name).map(([, value]) => value), buffer, size, cursor, end, written, 'values', 'request');
       },
       header_value_get(handle, namePointer, nameLength, valuePointer, valueLength, writtenOut) {
         const request = requests.get(Number(handle));
@@ -368,7 +412,7 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
         trace.push({ module: 'fastly_http_req', name: 'header_value_get', handle: Number(handle), header: name });
         if (!request) return FASTLY_STATUS_BADF;
         const value = headerValue(request.headers, name);
-        return value === undefined ? FASTLY_STATUS_NONE : writeUtf8(value, valuePointer, valueLength, writtenOut);
+        return value === undefined ? FASTLY_STATUS_INVALID_ARGUMENT : writeUtf8(value, valuePointer, valueLength, writtenOut);
       },
       new(handleOut) {
         const handle = alloc('request');
@@ -413,9 +457,27 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
       close(handle) { return requests.delete(Number(handle)) ? FASTLY_STATUS_OK : FASTLY_STATUS_BADF; },
       pending_req_poll_v2(handle, detail, done, responseOut, bodyOut) {
         const item = pending.get(Number(handle)); if (!item) return FASTLY_STATUS_BADF;
+        trace.push({module:'fastly_http_req',name:'pending_req_poll_v2',pendingHandle:Number(handle)});
         if (monotonicMs < item.readyAt) { writeU32(done, 0); return FASTLY_STATUS_OK; }
         writeU32(done, 1); return imports.fastly_http_req.pending_req_wait(handle, responseOut, bodyOut);
       },
+      send_async_streaming(handle, bodyHandle, backendPointer, backendLength, pendingOut) {
+        const request = requests.get(Number(handle)), body = bodies.get(Number(bodyHandle));
+        if (!request || !body) return FASTLY_STATUS_BADF;
+        const backend = readUtf8(backendPointer, backendLength);
+        const fixture = resolveFixture(options.fixtures, backend, request.method, request.url);
+        requests.delete(Number(handle));
+        if (!fixture || fixture.sendStatus) { bodies.delete(Number(bodyHandle)); return Number(fixture?.sendStatus || 1); }
+        const pendingHandle = alloc('pending');
+        const record = {backend, method:request.method, url:redactText(request.url), headers:redactRuntimeHeaders(request.headers), bodyBytes:Buffer.alloc(0)};
+        outboundRequests.push(record);
+        const item = {request, backend, fixture, readyAt:fixture.earlyResponse ? monotonicMs + Number(fixture.delayMs || 0) : Infinity};
+        pending.set(pendingHandle, item);
+        body.streamingUpload = {item, record}; body.readyAt = monotonicMs + Number(options.uploadReadyDelayMs || 0);
+        writeU32(pendingOut, pendingHandle);
+        trace.push({module:'fastly_http_req',name:'send_async_streaming',bodyHandle:Number(bodyHandle),pendingHandle});
+        return FASTLY_STATUS_OK;
+      },
       send_async(handle, bodyHandle, backendPointer, backendLength, pendingOut) {
         const request = requests.get(Number(handle));
         const body = bodies.get(Number(bodyHandle));
@@ -430,7 +492,7 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
         }
         const pendingHandle = alloc('pending');
         const capturedBody = bodyBytes(bodyHandle);
-        pending.set(pendingHandle, { request: { ...request, headers: request.headers.map((entry) => [...entry]), body: capturedBody }, backend, fixture, readyAt: monotonicMs + Number(fixture.delayMs || 0) });
+        pending.set(pendingHandle, { request: { ...request, headers: request.headers.map((entry) => [...entry]), body: capturedBody }, backend, fixture, readyAt: fixture.neverHeaders ? Infinity : monotonicMs + Number(fixture.delayMs || 0) });
         if (typeof options.onOutboundRequest === 'function') options.onOutboundRequest({ ...request, backend, headers: request.headers.map((entry) => [...entry]), body: capturedBody });
         if (fixture.sendStatus) { pending.delete(pendingHandle); return Number(fixture.sendStatus); }
         if (request.headers.some(([name, value]) => name.toLowerCase() === 'authorization' && value.startsWith('AWS4-HMAC-SHA256 '))) privateUrls.add(request.url);
@@ -576,13 +638,21 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
         trace.push({ module: 'fastly_http_resp', name: 'header_append', handle: Number(handle), header: [name, value] });
         return FASTLY_STATUS_OK;
       },
+      header_values_get(handle, pointer, length, buffer, size, cursor, end, written) {
+        trace.push({module:'fastly_http_resp', name:'header_values_get', cursor:Number(cursor)});
+        const response = responses.get(Number(handle));
+        if (!response) return FASTLY_STATUS_BADF;
+        const name = readUtf8(pointer, length).toLowerCase();
+        if (!/^[!#$%&'*+.^_`|~0-9a-z-]+$/.test(name)) return FASTLY_STATUS_INVALID_ARGUMENT;
+        return requestHeaderList(response.headers.filter(([key]) => key.toLowerCase() === name).map(([, value]) => value), buffer, size, cursor, end, written, 'response-values', 'response');
+      },
       header_value_get(handle, namePointer, nameLength, valuePointer, valueLength, writtenOut) {
         const response = responses.get(Number(handle));
         const name = readUtf8(namePointer, nameLength);
         trace.push({ module: 'fastly_http_resp', name: 'header_value_get', handle: Number(handle), header: name });
         if (!response) return FASTLY_STATUS_BADF;
         const value = headerValue(response.headers, name);
-        return value === undefined ? FASTLY_STATUS_NONE : writeUtf8(value, valuePointer, valueLength, writtenOut);
+        return value === undefined ? FASTLY_STATUS_INVALID_ARGUMENT : writeUtf8(value, valuePointer, valueLength, writtenOut);
       },
       status_get(handle, statusOut) {
         const response = responses.get(Number(handle));
@@ -612,11 +682,30 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
           responseHandle: Number(handle),
           bodyHandle: Number(bodyHandle)
         };
+        if (Number(streaming) === 1) responses.delete(Number(handle));
         return FASTLY_STATUS_OK;
       }
     },
     fastly_http_body: {
-      close(handle) { trace.push({ module: 'fastly_http_body', name: 'close', handle: Number(handle) }); if (downstream?.streaming && downstream.bodyHandle === Number(handle)) { downstream.bodyBytes = bodyBytes(handle); downstream.finished = true; } return bodies.delete(Number(handle)) ? FASTLY_STATUS_OK : FASTLY_STATUS_BADF; },
+      close(handle) {
+        trace.push({module:'fastly_http_body',name:'close',handle:Number(handle)});
+        const body = bodies.get(Number(handle));
+        if (body?.streamingUpload) {
+          const {item,record} = body.streamingUpload;
+          record.bodyBytes = bodyBytes(handle);
+          if (item.fixture.echoBody) item.fixture = {...item.fixture,body:record.bodyBytes};
+          item.readyAt = item.fixture.neverHeaders ? Infinity : monotonicMs + Number(item.fixture.delayMs || 0);
+        }
+        if (downstream?.streaming && downstream.bodyHandle === Number(handle)) { downstream.bodyBytes = bodyBytes(handle); downstream.finished = true; }
+        return bodies.delete(Number(handle)) ? FASTLY_STATUS_OK : FASTLY_STATUS_BADF;
+      },
+      abandon(handle) {
+        trace.push({module:'fastly_http_body',name:'abandon',handle:Number(handle)});
+        const body = bodies.get(Number(handle));
+        if (body?.streamingUpload) { body.streamingUpload.record.bodyBytes = bodyBytes(handle); body.streamingUpload.record.aborted = true; }
+        if (downstream?.streaming && downstream.bodyHandle === Number(handle)) { downstream.bodyBytes = bodyBytes(handle); downstream.aborted = true; }
+        return bodies.delete(Number(handle)) ? FASTLY_STATUS_OK : FASTLY_STATUS_BADF;
+      },
       new(handleOut) {
         const handle = alloc('body');
         bodies.set(handle, { bytes: Buffer.alloc(0), readOffset: 0, writes: [] });
@@ -635,19 +724,21 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
         body.readOffset = offset + count;
         body.readyAt = monotonicMs + Number(body.fixture && body.fixture.chunkDelayMs || 0);
         writeU32(readOut, count);
-        trace.push({ module: 'fastly_http_body', name: 'read', handle: Number(handle), bytes: count });
+        trace.push({ module: 'fastly_http_body', name: 'read', handle: Number(handle), bytes: count, ...(options.traceBodyIo === true ? {pointer:Number(buffer), capacity:Number(bufferLength), now:monotonicMs} : {}) });
         return FASTLY_STATUS_OK;
       },
       write(handle, buffer, bufferLength, end, writtenOut) {
         const body = bodies.get(Number(handle));
         if (!body) return FASTLY_STATUS_BADF;
         if (downstream?.streaming && Number(handle) === downstream.bodyHandle && options.downstreamBodyWriteStatus) return Number(options.downstreamBodyWriteStatus);
-        if (requests.size > 1 && options.outboundBodyWriteStatus) return Number(options.outboundBodyWriteStatus);
-        const length = Math.min(Number(bufferLength), Number(options.bodyWriteChunkBytes || bufferLength));
+        if ((requests.size > 1 || body.streamingUpload) && options.outboundBodyWriteStatus) return Number(options.outboundBodyWriteStatus);
+        const length = Math.min(Number(bufferLength), Number(options.bodyWriteChunkBytes ?? bufferLength));
         const bytes = readBytes(buffer, length);
         body.writes.push(bytes);
+        if (body.streamingUpload) body.readyAt = monotonicMs + Number(options.uploadWriteDelayMs || 0);
+        if (downstream?.streaming && downstream.bodyHandle === Number(handle)) body.readyAt = monotonicMs + Number(options.downstreamWriteDelayMs || 0);
         writeU32(writtenOut, bytes.length);
-        trace.push({ module: 'fastly_http_body', name: 'write', handle: Number(handle), bytes: bytes.length, end: Number(end) });
+        trace.push({ module: 'fastly_http_body', name: 'write', handle: Number(handle), bytes: bytes.length, end: Number(end), ...(options.traceBodyIo === true ? {pointer:Number(buffer), capacity:Number(bufferLength), now:monotonicMs} : {}) });
         return FASTLY_STATUS_OK;
       }
     }
@@ -662,11 +753,16 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
   // Throwing stops the Wasm invocation; it never fabricates an effect result.
   const checkActive = () => { if (options.signal && options.signal.aborted) throw options.signal.reason || new Error('Request cancelled.'); };
   checkActive();
-  if (options.signal || options.hostcallDelayMs) for (const [moduleName, namespace] of Object.entries(imports)) {
+  // A test-only post-call hook can corrupt ABI outputs or advance the clock.
+  // It observes the real generated guest; it is never used by provider execution.
+  if (options.signal || options.hostcallDelayMs || options.afterHostcall) for (const [moduleName, namespace] of Object.entries(imports)) {
     for (const [name, hostcall] of Object.entries(namespace)) if (typeof hostcall === 'function') namespace[name] = (...args) => {
       checkActive(); const result = hostcall(...args);
       monotonicMs += Number(options.hostcallDelayMs?.[`${moduleName}.${name}`] || 0);
-      checkActive(); return result;
+      const replacement = options.afterHostcall?.({module:moduleName,name,args,result,trace,
+        writeU32,writeU64,readU32:pointer=>view().getUint32(Number(pointer),true),
+        advance:ms=>{monotonicMs+=ms;}});
+      checkActive(); return replacement ?? result;
     };
   }
   const module = new WebAssembly.Module(wasm);
@@ -698,11 +794,20 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
   const pulseLastError = typeof instance.exports.pulse_last_error_code === 'function'
     ? Number(instance.exports.pulse_last_error_code())
     : undefined;
-  if (downstream?.streaming && !downstream.finished) { downstream.bodyBytes = bodyBytes(downstream.bodyHandle); downstream.aborted = true; }
+  if (downstream?.streaming && !downstream.finished) { downstream.bodyBytes = bodyBytes(downstream.bodyHandle) || downstream.bodyBytes; downstream.aborted = true; }
   const handledJwtError = options.allowHandledJwtError === true
     && lastError === 1008
     && Boolean(downstream);
-  if (lastError !== FASTLY_STATUS_OK && !handledJwtError && !(options.allowAbortedResponse === true && downstream?.aborted)) {
+  const handledHeaderError = options.allowHandledHeaderError === true
+    && lastError === 1003 && (errorStage === 22 || errorStage === 23) && downstream?.status === 500;
+  const handledTransportError = options.allowHandledTransportError === true
+    && (errorStage === 77 || errorStage === 81)
+    && ((lastError === 1006 && downstream?.status === 502) || (lastError === 1003 && downstream?.status === 500));
+  const handledDeadlineError = options.allowHandledFetchDeadlineError === true
+    && ((lastError === 1006 && errorStage === 271 && downstream?.status === 504)
+      || (lastError === 1001 && errorStage === 270 && downstream?.status === 400)
+      || (lastError === 1003 && errorStage === 272 && downstream?.status === 500));
+  if (lastError !== FASTLY_STATUS_OK && !handledDeadlineError && !handledTransportError && !handledHeaderError && !handledJwtError && !(options.allowAbortedResponse === true && downstream?.aborted)) {
     throw new FastlyNativePlatformCapabilitiesMockError('Fastly native platform capabilities module reported an execution error.', 'PULSE_FASTLY_NATIVE_PLATFORM_CAPABILITIES_MOCK_EXECUTION_FAILED', { lastError, errorStage, errorEffect, pulseLastError, trace });
   }
   if (!downstream) {
@@ -729,6 +834,16 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
     outboundRequests: Object.freeze(outboundRequests),
     stores: Object.freeze({ config: snapshotStores(configStores), secrets: Object.fromEntries([...secretStores].map(([name, values]) => [name, Object.fromEntries([...values].map(([key]) => [key, '[REDACTED]']))])), kv: snapshotStores(kvStores, true) }),
     kvEvidence,
+    monotonicMs,
+    transportResources: Object.freeze({pendingRequests: pending.size,
+      outboundRequests: requests.size - Number(requests.has(downstreamRequestHandle))}),
+    // Non-streaming send transfers these two handles even though the fixture
+    // keeps their bytes for assertions. Pending work is counted separately:
+    // Fastly has no cancellation hostcall for an unresolved pending request.
+    forwardingResources: Object.freeze({
+      bodies: bodies.size - Number(!downstream?.streaming && bodies.has(downstream?.bodyHandle)),
+      responses: responses.size - Number(!downstream?.streaming && responses.has(downstream?.responseHandle))
+    }),
     instance
   });
 }

package/src/toolchain/body-forwarding.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const MAX_BODY_BYTES = 1048576;
+function forwardingError(message) {
+  const error = new TypeError(message);
+  error.code = 'PULSE_FASTLY_BODY_FORWARDING_INVALID';
+  return error;
+}
+function normalizeBodyForwarding(value, maxDurationMs) {
+  if (value === undefined) return undefined;
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || Object.keys(value).some(key => !['requestMaxBytes', 'responseMaxBytes'].includes(key))) {
+    throw forwardingError('fastly.bodyForwarding requires requestMaxBytes and responseMaxBytes.');
+  }
+  for (const key of ['requestMaxBytes', 'responseMaxBytes']) {
+    if (!Number.isInteger(value[key]) || value[key] < 1 || value[key] > MAX_BODY_BYTES) {
+      throw forwardingError(`fastly.bodyForwarding.${key} must be an integer from 1 to ${MAX_BODY_BYTES}.`);
+    }
+  }
+  if (!Number.isInteger(maxDurationMs) || maxDurationMs < 1 || maxDurationMs > 30000) {
+    throw forwardingError('fastly.bodyForwarding requires maxDurationMs from 1 to 30000.');
+  }
+  return Object.freeze({requestMaxBytes: value.requestMaxBytes, responseMaxBytes: value.responseMaxBytes});
+}
+module.exports = {normalizeBodyForwarding, forwardingError, MAX_BODY_BYTES};

package/src/toolchain/config.js

@@ -34,6 +34,7 @@ function normalizeFastlyProviderConfig(value) {
     : {};
   return Object.freeze({
     kind: 'fastly',
+    bodyForwarding: require('./body-forwarding.js').normalizeBodyForwarding(input.bodyForwarding, input.maxDurationMs),
     maxDurationMs: require('@pulse-compute/runtime/host').normalizeRequestDuration(input.maxDurationMs),
     version: input.version ? String(input.version) : undefined,
     bindings: Object.freeze({
@@ -71,6 +72,7 @@ function fastlyProjectConfigDocument(config) {
     kind: 'fastly',
     bindings: config.bindings,
     maxDurationMs: config.maxDurationMs,
+    bodyForwarding: config.bodyForwarding,
     build: config.build,
     local: config.local,
     providerSpecificUserland: false
@@ -104,6 +106,8 @@ const FASTLY_PROJECT_CONFIG_REFERENCE = Object.freeze({
     })
   ]),
   fields: Object.freeze([
+    Object.freeze({section:'fastly',path:'fastly.bodyForwarding',type:'object',default:'omitted',scope:'experimental Fastly Native forwarding',description:'Opt in to one terminal opaque POST with inline req.body() and a static backend. Requires maxDurationMs and both byte limits. Final close hands queued delivery to Fastly; it is not a client receipt.',diagnostics:Object.freeze(['PULSE_FASTLY_BODY_FORWARDING_INVALID'])}),
+    ...['requestMaxBytes','responseMaxBytes'].map(name => Object.freeze({section:'fastly',path:`fastly.bodyForwarding.${name}`,type:'integer',allowed:'1–1048576',default:'required with bodyForwarding',scope:'experimental Fastly Native forwarding',description:'Independent actual-byte bound, including EOF verification; no unbounded default. Fixed 16 KiB raw scratch is reused across the sequential upload and response pumps.'})),
     Object.freeze({section:'fastly',path:'fastly.maxWasmBytes',type:'integer',allowed:'positive safe integer',default:'4194304 (4 MiB)',scope:'fastly() facade',description:'Facade option projected to build.maxWasmBytes. Conventional profiles configure fastly.build.maxWasmBytes.'}),
     Object.freeze({section:'fastly',path:'fastly.build.maxWasmBytes',type:'integer',allowed:'positive safe integer',default:'4194304 (4 MiB)',scope:'Native final Wasm artifact',description:'Inclusive byte budget checked for newly compiled and reused artifacts. Raising it does not increase runtime memory or change Fastly service limits. The fastly() facade accepts maxWasmBytes.'}),
     Object.freeze({section:'fastly',path:'fastly.maxDurationMs',type:'integer',allowed:'1–30000',default:'omitted',scope:'HTTP request execution',description:'One provider-owned monotonic budget through buffered response handoff; expiry attempts 504 before headers commit and never asserts rollback of dispatched writes. No CPU preemption or post-handoff delivery guarantee.'}),

package/src/toolchain/index.js

@@ -271,7 +271,7 @@ function createDriver() {
     execute: fastlyRuntime.executeCanonicalProgram,
     prepareNativeExecution: require('./native-execution.js').prepareFastlyNativeExecution,
     createLoweringPlan(metadata, providerConfig = {}) {
-      return createFastlyLoweringPlan(metadata, providerConfig.bindings || {});
+      return createFastlyLoweringPlan(metadata, providerConfig.bindings || {}, providerConfig);
     },
     inspectRealization(invocation) {
       const realization = inspectFastlyCanonicalTarget({
@@ -285,6 +285,7 @@ function createDriver() {
         realizationArtifacts: invocation.nativeArtifact.realizationArtifacts,
         guestUnits: invocation.nativeArtifact.guestUnits,
         nativeOptimization: invocation.optimization,
+        elideJsonCacheArena: invocation.nativeArtifact.manifest.elideJsonCacheArena === true,
         emitWat: invocation.nativeArtifact.manifest.wat?.emitted === true,
         compileTimeoutMs: invocation.timeoutMs
       });
@@ -314,6 +315,7 @@ function createDriver() {
         realizationArtifacts: invocation.nativeArtifact.realizationArtifacts,
         guestUnits: invocation.nativeArtifact.guestUnits,
         nativeOptimization: invocation.optimization,
+        elideJsonCacheArena: invocation.nativeArtifact.manifest.elideJsonCacheArena === true,
         emitWat: invocation.nativeArtifact.manifest.wat?.emitted === true,
         compileTimeoutMs: invocation.timeoutMs
       });
@@ -350,7 +352,7 @@ function createDriver() {
           providerPackage: providerBuild.packageFile,
           providerSourceEntry: providerBuild.sourceEntryFile
         }),
-        build: { ...providerBuild.build, reportAttribution: native.reportAttribution },
+        build: { ...providerBuild.build, reportAttribution: native.reportAttribution, buildObservation: native.buildObservation },
         realization: publicRealization,
         packaging: audit ? Object.freeze({
           version: PROVIDER_PACKAGING_AUDIT_VERSION,

package/src/toolchain/native-execution.js

@@ -18,6 +18,7 @@ function prepareFastlyNativeExecution(invocation) {
     realizationArtifacts: invocation.nativeArtifact.realizationArtifacts,
     guestUnits: invocation.nativeArtifact.guestUnits,
     nativeOptimization: invocation.optimization,
+    elideJsonCacheArena: invocation.nativeArtifact.manifest.elideJsonCacheArena === true,
     emitWat: invocation.nativeArtifact.manifest.wat?.emitted === true,
     compileTimeoutMs: invocation.timeoutMs || undefined
   });
@@ -58,7 +59,12 @@ function prepareFastlyNativeExecution(invocation) {
       response: Object.freeze({
         ...execution.response,
         kind: type.includes('application/json') || type.includes('+json') ? 'json' : type.startsWith('text/') ? 'text' : 'response',
-        bodyClass: execution.response.origin === true ? 'opaque' : 'structured'
+        // Forwarding filters origin metadata into a new response handle, so
+        // its streamed payload remains opaque even though origin is false.
+        // Pre-commit errors use ordinary non-streaming structured responses.
+        bodyClass: execution.response.origin === true
+          || (native.plan.capabilities.includes('request.body.forward') && execution.response.streaming === 1)
+          ? 'opaque' : 'structured'
       }),
       // The fixture ABI has hostcall traces, not canonical continuation telemetry.
       effectCount: null,