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

package/src/testing/native-platform-capabilities-host.js

@@ -254,6 +254,14 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
   }
   const imports = {
     fastly_async_io: {
+      is_ready(handle, out) {
+        const item = pending.get(Number(handle)) || bodies.get(Number(handle));
+        if (!item) return FASTLY_STATUS_BADF;
+        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));
@@ -270,6 +278,28 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
       }
     },
     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);
@@ -312,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;
@@ -426,6 +461,23 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
         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));
@@ -630,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: [] });
@@ -653,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;
       }
     }
@@ -680,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);
@@ -716,7 +794,7 @@ 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);
@@ -759,6 +837,13 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
     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({

package/src/toolchain/native-execution.js

@@ -59,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,