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

package/src/build/response-authority.js

@@ -0,0 +1,56 @@
+'use strict';
+
+// Adapted from HEX research ecc36468b5900a0de57a415379b85d12c5026f3f; structural emission.
+
+const { httpLifecycle } = require('@pulse-compute/wasm-contracts/provider/toolchain');
+if (httpLifecycle.VERSION !== 'pulse.http-lifecycle.v1') throw bindingError('Unsupported HTTP lifecycle contract version.');
+const { AUTHORITY } = httpLifecycle;
+// Fastly owns this diagnostic/runtime encoding; shared contracts use names.
+const STATES = Object.freeze({ owned: 0, 'outcome-unknown': 1, transferred: 2, completed: 3 });
+if (AUTHORITY.states.length !== Object.keys(STATES).length || AUTHORITY.states.some(state => !Object.hasOwn(STATES, state)))
+  throw bindingError('Fastly response-authority encoding does not cover the shared contract.');
+const dispatch = AUTHORITY.transitions.dispatch;
+const transfer = AUTHORITY.transitions.transfer;
+const complete = AUTHORITY.transitions.complete;
+const mayRespond = AUTHORITY.mayRespond.map(state => `__pulse_response_authority == ${STATES[state]}`).join(' || ');
+
+function bindingError(message) {
+  return Object.assign(new Error(message), { code: 'PULSE_FASTLY_LIFECYCLE_HOOK_INVALID' });
+}
+
+// Driver-owned downstream authority, selected only by services that need it.
+// This is not resource ownership: streaming writers and borrowed request handles
+// still require their service's qualified disposal policy.
+function runtimeSource() {
+  return `
+// 0 owned; 1 dispatch outcome unknown; 2 transferred; 3 locally completed.
+// Completion is not a delivery receipt. Nonzero status or trap never reopens it.
+let __pulse_response_authority: i32 = ${STATES[AUTHORITY.initial]}
+function __pulse_response_owned(): bool { return ${mayRespond} }
+function __pulse_response_begin(): bool {
+  if (!__pulse_response_owned()) { __pulse_fastly_fail(PULSE_ERROR_STATE, 282, -1); return false }
+  __pulse_response_authority = ${STATES[dispatch.to]}
+  return true
+}
+function __pulse_response_transferred(): void {
+  if (__pulse_response_authority == ${STATES[transfer.from]}) __pulse_response_authority = ${STATES[transfer.to]}
+}
+function __pulse_response_complete(): void {
+  if (__pulse_response_authority == ${STATES[complete.from]}) __pulse_response_authority = ${STATES[complete.to]}
+}
+function fastly_http_resp_send_downstream(handle: i32, body: i32, streaming: i32): i32 {
+  if (!__pulse_response_begin()) return PULSE_ERROR_STATE
+  const status = __pulse_response_send_raw(handle, body, streaming)
+  if (status == 0) {
+    __pulse_response_transferred()
+    if (streaming == 0) __pulse_response_complete()
+  }
+  return status
+}
+`;
+}
+function hooks() {
+  return [{ point: 'response.authority', owner: 'driver.response', order: -100,
+    body: '  return __pulse_response_owned()' }];
+}
+module.exports = { STATES, runtimeSource, hooks };

package/src/javascript/fetch-adapter.js

@@ -53,7 +53,9 @@ function createFastlyJavascriptFetchCapability(options = {}) {
       ...(configuredBackend ? { backend: configuredBackend } : {})
     };
     try {
+      execution.fetchTiming?.begin();
       const response = await implementation(String(url), requestInit);
+      execution.fetchTiming?.headers();
       if (!(response instanceof Response) && !runtimeHost.isPulseFetchResponse(response)) {
         throw fastlyJavascriptProviderError(
           'PULSE_FASTLY_FETCH_RESPONSE_INVALID',
@@ -63,6 +65,7 @@ function createFastlyJavascriptFetchCapability(options = {}) {
       }
       return response;
     } catch (error) {
+      execution.fetchTiming?.fail();
       if (isPulseRuntimeError(error)) throw error;
       if (requestInit.signal && requestInit.signal.aborted) {
         const reason = requestInit.signal.reason;

package/src/javascript/runtime-host.js

@@ -72,6 +72,7 @@ async function executeFastlyJavascriptApplication(application, request, options
     maxEffects: options.maxEffects,
     maxRequestBodyBytes: options.maxRequestBodyBytes,
     maxFetchBodyBytes: options.maxFetchBodyBytes,
+    fetchClock: options.fetchClock,
     maxStructuredBodyBytes: options.maxStructuredBodyBytes,
     maxBindingNameBytes: options.maxBindingNameBytes,
     maxBindingValueBytes: options.maxBindingValueBytes,

package/src/provider-contract.js

@@ -12,12 +12,13 @@ const FASTLY_PROVIDER_DESCRIPTOR = canonical.normalizeDescriptor({
   deployable: true,
   localExecution: true,
   capabilities: [
-    'request', 'request.body.forward', 'response.json', 'response.text', 'response.custom', 'fetch',
+    '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',

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

@@ -223,6 +223,15 @@ 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));

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

@@ -483,6 +483,16 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
         trace.push({ module: 'fastly_http_req', name: 'header_insert', handle: Number(handle), header: redactRuntimeHeaders([[name, value]], privateUrls.has(request.url))[0] });
         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);
+        if (name.toLowerCase() === 'authorization' && value.includes('/s3/aws4_request')) privateUrls.add(request.url);
+        request.headers.push([name, value]);
+        trace.push({ module: 'fastly_http_req', name: 'header_append', handle: Number(handle), header: redactRuntimeHeaders([[name, value]], privateUrls.has(request.url))[0] });
+        return FASTLY_STATUS_OK;
+      },
       cache_override_set(handle, tag, ttl, swr) {
         const request = requests.get(Number(handle)); if (!request) return FASTLY_STATUS_BADF;
         request.cacheOverride = Number(tag); return FASTLY_STATUS_OK;

package/src/toolchain/index.js

@@ -168,6 +168,7 @@ function createDriver() {
         version: 'pulse.provider-target-descriptor.v1',
         target: 'native',
         targetId: 'fastly-compute-native',
+        hostExtensions: require('../build/host-extensions.js').ADMISSION,
         runtimeClass: 'native',
         status: 'supported',
         capabilities: Object.freeze([
@@ -361,7 +362,7 @@ function createDriver() {
           providerPackage: providerBuild.packageFile,
           providerSourceEntry: providerBuild.sourceEntryFile
         }),
-        build: { ...providerBuild.build, reportAttribution: native.reportAttribution, buildObservation: native.buildObservation },
+        build: { ...providerBuild.build, reportAttribution: native.reportAttribution, hostExtensions: native.manifest.hostExtensions, buildObservation: native.buildObservation },
         realization: publicRealization,
         packaging: audit ? Object.freeze({
           version: PROVIDER_PACKAGING_AUDIT_VERSION,

package/src/toolchain/native-execution.js

@@ -28,9 +28,11 @@ function prepareFastlyNativeExecution(invocation) {
     target: 'fastly-compute-native',
     wasmSha256: native.manifest.wasm.sha256,
     providerRealityValidated: false,
-    effectObservations: 'unavailable'
+    effectObservations: 'unavailable',
+    kvFixture: Object.freeze({ lifetime: 'invocation', initialization: 'supplied-fixtures', crossRequestPersistence: false }),
+    notice: 'KV fixture state is seeded from supplied fixtures for each invocation; writes do not persist across requests. Use the Fastly CLI/Viceroy workflow for local provider persistence and contention checks; deployed-service acceptance is separate.'
   });
-  return (options = {}) => {
+  const execute = (options = {}) => {
     if (options.liveFetch === true) throw new TypeError('Fastly Native fixture execution cannot perform live fetches.');
     const kvStores = {};
     for (const [logical, physical] of Object.entries(bindings.kv || {})) {
@@ -73,6 +75,9 @@ function prepareFastlyNativeExecution(invocation) {
       evidence
     });
   };
+  // Public observation already returned with execution results, available before
+  // the first request without running a probe or acquiring additional authority.
+  return Object.freeze(Object.assign(execute, { evidence }));
 }
 
 module.exports = { prepareFastlyNativeExecution };