@pulse-compute/provider-fastly 1.0.0-beta.4 → 1.0.0-beta.6

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',

package/src/provider-contract.js

@@ -13,9 +13,9 @@ const FASTLY_PROVIDER_DESCRIPTOR = canonical.normalizeDescriptor({
   localExecution: true,
   capabilities: [
     'request', 'response.json', 'response.text', 'response.custom', 'fetch',
-    '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',
-    'opaque.pass-through', 's3.head', 's3.getText', 's3.putText'
+    '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',
@@ -23,6 +23,8 @@ const FASTLY_PROVIDER_DESCRIPTOR = canonical.normalizeDescriptor({
     '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',
@@ -36,8 +38,10 @@ const FASTLY_PROVIDER_DESCRIPTOR = canonical.normalizeDescriptor({
     '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'
   }

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

@@ -344,6 +344,8 @@ function createFastlyProviderAdapter(baseOptions = {}) {
     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/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]) });
@@ -230,7 +231,9 @@ function executeFastlyNativeHttpEffects(input, options = {}) {
           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 +376,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
   });
 }

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

@@ -143,7 +143,8 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
   const downstreamRequestHandle = 1;
   const downstreamBodyHandle = 2;
   requests.set(downstreamRequestHandle, { method, url, headers: requestHeaders.map((entry) => [...entry]) });
-  bodies.set(downstreamBodyHandle, { bytes: normalizeBody(requestInput.body), readOffset: 0, writes: [] });
+  bodies.set(downstreamBodyHandle, { bytes: normalizeBody(requestInput.body), readOffset: 0, writes: [],
+    readyAt: monotonicMs + Number(requestInput.readyDelayMs || 0), fixture: requestInput });
   let downstream;
 
   function alloc(kind = 'default') {
@@ -203,6 +204,15 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
       body = JSON.stringify(normalized.json);
       if (!headers.some(([name]) => name.toLowerCase() === 'content-type')) headers.push(['content-type', 'application/json; charset=utf-8']);
     }
+    // Ordinary Pulse harness fixtures use value/text; preserve the ABI fixture
+    // body's explicit precedence and its existing json shorthand.
+    if (body === undefined && Object.prototype.hasOwnProperty.call(normalized, 'value')) {
+      body = JSON.stringify(normalized.value);
+      if (!headers.some(([name]) => name.toLowerCase() === 'content-type')) headers.push(['content-type', 'application/json; charset=utf-8']);
+    } else if (body === undefined && Object.prototype.hasOwnProperty.call(normalized, 'text')) {
+      body = String(normalized.text);
+      if (!headers.some(([name]) => name.toLowerCase() === 'content-type')) headers.push(['content-type', 'text/plain; charset=utf-8']);
+    }
     responses.set(responseHandle, {
       status: Number(normalized.status || 200),
       headers,
@@ -219,6 +229,28 @@ 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) {
+    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;
+    while (index < values.length) {
+      const bytes = Buffer.from(String(values[index]) + '\0');
+      if (count + bytes.length > limit) {
+        if (count === 0) { writeU32(written, bytes.length); return FASTLY_STATUS_BUFLEN; }
+        break;
+      }
+      new Uint8Array(memory().buffer, Number(buffer) + count, bytes.length).set(bytes);
+      count += bytes.length; index++;
+    }
+    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)});
+    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;
+    return fault?.status ?? FASTLY_STATUS_OK;
+  }
   const imports = {
     fastly_async_io: {
       select(handles, count, timeout, done) {
@@ -235,6 +267,19 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
     },
     wasi_snapshot_preview1: {
       clock_time_get(clockId, precision, timeOut) {
+        if (Number(clockId) === 1 && typeof options.monotonicClock === 'function') {
+          const sample = options.monotonicClock(monotonicMs);
+          if (sample.status) return sample.status;
+          writeU64(timeOut, sample.nanoseconds);
+          return FASTLY_STATUS_OK;
+        }
+        if (Number(clockId) === 0 && typeof options.realtimeClock === 'function') {
+          const sample = options.realtimeClock();
+          trace.push({ module: 'wasi_snapshot_preview1', name: 'clock_time_get', clockId: 0, precision: String(precision), status: sample.status || 0 });
+          if (sample.status) return sample.status;
+          writeU64(timeOut, sample.nanoseconds);
+          return FASTLY_STATUS_OK;
+        }
         const seconds = Number.isFinite(Number(options.clockUnixSeconds))
           ? Number(options.clockUnixSeconds)
           : Math.floor(Date.now() / 1000);
@@ -304,6 +349,19 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
         trace.push({ module: 'fastly_http_req', name: 'uri_get', handle: Number(handle) });
         return request ? writeUtf8(request.url, buffer, bufferLength, writtenOut) : FASTLY_STATUS_BADF;
       },
+      header_names_get(handle, buffer, size, cursor, end, written) {
+        trace.push({module: 'fastly_http_req', name: 'header_names_get', cursor: Number(cursor)});
+        const request = requests.get(Number(handle));
+        if (!request) return FASTLY_STATUS_BADF;
+        return requestHeaderList([...new Set(request.headers.map(([name]) => name.toLowerCase()))], buffer, size, cursor, end, written, 'names');
+      },
+      header_values_get(handle, pointer, length, buffer, size, cursor, end, written) {
+        trace.push({module: 'fastly_http_req', name: 'header_values_get', cursor: Number(cursor)});
+        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');
+      },
       header_value_get(handle, namePointer, nameLength, valuePointer, valueLength, writtenOut) {
         const request = requests.get(Number(handle));
         const name = readUtf8(namePointer, nameLength);
@@ -558,7 +616,7 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
       }
     },
     fastly_http_body: {
-      close(handle) { trace.push({ module: 'fastly_http_body', name: 'close' }); return bodies.delete(Number(handle)) ? FASTLY_STATUS_OK : FASTLY_STATUS_BADF; },
+      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; },
       new(handleOut) {
         const handle = alloc('body');
         bodies.set(handle, { bytes: Buffer.alloc(0), readOffset: 0, writes: [] });
@@ -583,6 +641,7 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
       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));
         const bytes = readBytes(buffer, length);
@@ -603,9 +662,11 @@ 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) for (const namespace of Object.values(imports)) {
+  if (options.signal || options.hostcallDelayMs) 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); checkActive(); return result;
+      checkActive(); const result = hostcall(...args);
+      monotonicMs += Number(options.hostcallDelayMs?.[`${moduleName}.${name}`] || 0);
+      checkActive(); return result;
     };
   }
   const module = new WebAssembly.Module(wasm);
@@ -614,7 +675,16 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
     throw new FastlyNativePlatformCapabilitiesMockError('Pass98 native module is missing _start.', 'PULSE_FASTLY_NATIVE_PLATFORM_CAPABILITIES_MOCK_START_MISSING');
   }
   if (options.conditionalKv && options.conditionalKv.deadlineNs !== undefined) instance.exports.pulse_fastly_kv_request_deadline(BigInt(options.conditionalKv.deadlineNs));
-  instance.exports._start();
+  try { instance.exports._start(); }
+  catch (error) {
+    if (Number(instance.exports.pulse_fastly_last_error?.()) !== 1010) throw error;
+    throw new FastlyNativePlatformCapabilitiesMockError('Native retained-value budget exceeded.',
+      'PULSE_RUNTIME_MEMORY_LIMIT_EXCEEDED', {
+        lastError: 1010, errorStage: Number(instance.exports.pulse_fastly_error_stage()), trace,
+        bytes: Number(instance.exports.pulse_fastly_memory_bytes()),
+        values: Number(instance.exports.pulse_fastly_memory_values())
+      });
+  }
   for (const entry of trace) if (entry.url && privateUrls.has(entry.url)) entry.url = '[REDACTED]';
   const lastError = typeof instance.exports.pulse_fastly_last_error === 'function'
     ? Number(instance.exports.pulse_fastly_last_error())
@@ -628,10 +698,11 @@ 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; }
   const handledJwtError = options.allowHandledJwtError === true
     && lastError === 1008
     && Boolean(downstream);
-  if (lastError !== FASTLY_STATUS_OK && !handledJwtError) {
+  if (lastError !== FASTLY_STATUS_OK && !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) {
@@ -648,6 +719,7 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
       bodyBytes: downstream.bodyBytes,
       sent: true,
       streaming: downstream.streaming,
+      aborted: downstream.aborted === true,
       origin: downstream.origin,
       responseHandle: downstream.responseHandle,
       bodyHandle: downstream.bodyHandle

package/src/toolchain/config.js

@@ -1,4 +1,5 @@
 'use strict';
+const { normalizeFastlyMaxWasmBytes } = require('../build/wasm-budget.js');
 const { normalizeFastlyS3 } = require('./s3.js');
 
 function providerConfigError(code, message, detail) {
@@ -33,6 +34,7 @@ function normalizeFastlyProviderConfig(value) {
     : {};
   return Object.freeze({
     kind: 'fastly',
+    maxDurationMs: require('@pulse-compute/runtime/host').normalizeRequestDuration(input.maxDurationMs),
     version: input.version ? String(input.version) : undefined,
     bindings: Object.freeze({
       configStore: String(bindings.configStore || 'pulse_config'),
@@ -54,6 +56,7 @@ function normalizeFastlyProviderConfig(value) {
       dynamicBackends: bindings.dynamicBackends === true
     }),
     build: Object.freeze({
+      maxWasmBytes: normalizeFastlyMaxWasmBytes(input.build?.maxWasmBytes),
       name: String(input.build && input.build.name || 'pulse-app'),
       description: String(input.build && input.build.description || 'Pulse application'),
       authors: Object.freeze(Array.isArray(input.build && input.build.authors) ? input.build.authors.map(String) : [])
@@ -67,6 +70,7 @@ function fastlyProjectConfigDocument(config) {
   return Object.freeze({
     kind: 'fastly',
     bindings: config.bindings,
+    maxDurationMs: config.maxDurationMs,
     build: config.build,
     local: config.local,
     providerSpecificUserland: false
@@ -100,7 +104,10 @@ const FASTLY_PROJECT_CONFIG_REFERENCE = Object.freeze({
     })
   ]),
   fields: Object.freeze([
-    Object.freeze({ section: 'fastly', path: 'fastly.bindings.s3', type: 'Readonly<Record<string, S3Binding & { backend: string }>>', default: '`{}`', scope: 'Fastly Native S3', description: 'Maps logical names to fixed HTTPS endpoint, bucket, region, named static backend, accessKeyIdSecret, secretAccessKeySecret, optional sessionTokenSecret, maxTextBytes (1–32768, default 32768) and timeoutMs (1–30000, default 10000).', security: 'Credentials resolve through the configured Secret Store at execution. Dynamic backend authority and guest endpoint overrides are forbidden.' }),
+    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.'}),
+    Object.freeze({ section: 'fastly', path: 'fastly.bindings.s3', type: 'Readonly<Record<string, S3Binding & { backend: string }>>', default: '`{}`', scope: 'Fastly Native S3', description: 'Maps logical names to fixed HTTPS endpoint, bucket, region, named static backend, accessKeyIdSecret, secretAccessKeySecret, optional sessionTokenSecret, maxTextBytes (1–2097152, default 32768) and timeoutMs (1–30000, default 10000).', security: 'Credentials resolve through the configured Secret Store at execution. Dynamic backend authority and guest endpoint overrides are forbidden.' }),
     Object.freeze({ section: 'fastly', path: 'fastly.configStore', type: 'string', default: '`pulse_config`', scope: 'Fastly config capability', description: 'Fastly Config Store resource name.' }),
     Object.freeze({ section: 'fastly', path: 'fastly.secretStore', type: 'string', default: '`pulse_secrets`', scope: 'Fastly secret capability', description: 'Fastly Secret Store resource name.', security: 'The name is build metadata; secret values are never embedded by this option.' }),
     Object.freeze({ section: 'fastly', path: 'fastly.kv', type: 'Readonly<Record<string, string>>', default: '`{}`', scope: 'Fastly KV capability', description: 'Maps logical ctx.kv names to Fastly KV Store resource names.', diagnostics: Object.freeze(['PULSE_FASTLY_KV_BINDINGS_INVALID']) }),

package/src/toolchain/index.js

@@ -169,16 +169,25 @@ function createDriver() {
         runtimeClass: 'native',
         status: 'supported',
         capabilities: Object.freeze([
-          's3.head', 's3.getText',
+          's3.head', 's3.getText', 's3.getBody',
           'kv.getVersioned', 'kv.insertIfAbsent', 'kv.compareAndSwap',
           'jwt.verify',
+          'jwt.sign',
           'jwt.verify.hs256',
           'jwt.verify.es256',
+          'jwt.verify.rs256',
           'secret.get',
           'time.wall-clock'
         ]),
         keyTypes: Object.freeze(['secret', 'jwk', 'jwks']),
         realizations: Object.freeze([
+          Object.freeze({
+            kind: 'package-native-application',
+            contractId: 'pulse.entities',
+            implementation: 'pulse.package-native-application.v1',
+            implemented: true,
+            automaticFallback: false
+          }),
           Object.freeze({
             kind: 'crypto-composed',
             realization: 'guest-source:pulse-hmac-as',
@@ -204,6 +213,19 @@ function createDriver() {
             guestUnitRequired: true,
             portable: true,
             automaticFallback: false
+          }),
+          Object.freeze({
+            kind: 'crypto-composed',
+            realization: 'guest-linked:pulse-rs256-bearssl-i31',
+            implementation: 'bearssl.0.6.rsa-i31.sha256.v1',
+            algorithms: Object.freeze(['RS256']),
+            keyTypes: Object.freeze(['jwk', 'jwks']),
+            implemented: true,
+            status: 'implemented-g4',
+            semanticOwner: '@pulse-compute/crypto',
+            guestUnitRequired: true,
+            portable: true,
+            automaticFallback: false
           })
         ]),
         jwt: Object.freeze({
@@ -233,6 +255,11 @@ function createDriver() {
             realization: 'guest-linked:pulse-es256-rustcrypto-p256',
             implemented: true,
             status: 'implemented-g4'
+          }, {
+            algorithm: 'RS256',
+            realization: 'guest-linked:pulse-rs256-bearssl-i31',
+            implemented: true,
+            status: 'implemented-g4'
           }]
         }),
         finalWasmPolicy: fastlyFinalWasmPolicy,
@@ -258,6 +285,7 @@ function createDriver() {
         realizationArtifacts: invocation.nativeArtifact.realizationArtifacts,
         guestUnits: invocation.nativeArtifact.guestUnits,
         nativeOptimization: invocation.optimization,
+        emitWat: invocation.nativeArtifact.manifest.wat?.emitted === true,
         compileTimeoutMs: invocation.timeoutMs
       });
       const { native, ...publicRealization } = realization;
@@ -286,6 +314,7 @@ function createDriver() {
         realizationArtifacts: invocation.nativeArtifact.realizationArtifacts,
         guestUnits: invocation.nativeArtifact.guestUnits,
         nativeOptimization: invocation.optimization,
+        emitWat: invocation.nativeArtifact.manifest.wat?.emitted === true,
         compileTimeoutMs: invocation.timeoutMs
       });
       const providerBuild = writeFastlyCanonicalTarget({
@@ -332,7 +361,7 @@ function createDriver() {
       });
     },
     executionOptions(providerConfig = {}, values = {}) {
-      return { ...values, bindings: providerConfig.bindings };
+      return { ...values, maxDurationMs: providerConfig.maxDurationMs, bindings: providerConfig.bindings };
     }
   });
 }

package/src/toolchain/native-execution.js

@@ -18,6 +18,7 @@ function prepareFastlyNativeExecution(invocation) {
     realizationArtifacts: invocation.nativeArtifact.realizationArtifacts,
     guestUnits: invocation.nativeArtifact.guestUnits,
     nativeOptimization: invocation.optimization,
+    emitWat: invocation.nativeArtifact.manifest.wat?.emitted === true,
     compileTimeoutMs: invocation.timeoutMs || undefined
   });
   const evidence = Object.freeze({

package/src/toolchain/s3.js

@@ -17,10 +17,10 @@ function normalizeFastlyS3(input = {}) {
 function resolveFastlyS3(effects, input) {
   const configured = normalizeFastlyS3(input);
   return Object.freeze(effects.flatMap((effect, index) => {
-    if (!['s3.head', 's3.getText', 's3.putText'].includes(effect.kind)) return [];
+    if (!['s3.head', 's3.getText', 's3.putText', 's3.getBody'].includes(effect.kind)) return [];
     const name = effect.resource && effect.resource.binding;
     if (!Object.hasOwn(configured, name)) throw new TypeError('The required Fastly S3 binding is missing.');
-    return [Object.freeze({ index, ...configured[name], contentType: effect.operation === 'putText' ? require('@pulse-compute/s3/provider').normalizePutOptions({ contentType: effect.payload && effect.payload.contentType }).contentType : '' })];
+    return [Object.freeze({ index, ...configured[name], ...(effect.operation === 'getBody' ? require('@pulse-compute/s3/provider').normalizeBodyOptions(Object.fromEntries(['method', 'range', 'ifNoneMatch'].filter(key => effect.payload?.[key] !== undefined).map(key => [key, effect.payload[key]]))) : {}), contentType: effect.operation === 'putText' ? require('@pulse-compute/s3/provider').normalizePutOptions({ contentType: effect.payload && effect.payload.contentType }).contentType : '' })];
   }));
 }
 module.exports = { normalizeFastlyS3, resolveFastlyS3 };