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

package/src/build/native-body-forwarding.as.ts

@@ -0,0 +1,334 @@
+// FWD9-02: sequential upload/response pumps. Payload bytes never become Pulse
+// values. Fixed scratch and ABI outputs are reused, including the clock slot.
+// close accepts EOF into Fastly; it is not a delivery/drain receipt.
+@external('fastly_http_req', 'send_async_streaming')
+declare function __fwd_dispatch(request: i32, body: i32, backend: usize, length: i32, pending: usize): i32
+@external('fastly_http_body', 'abandon') declare function __fwd_abandon(body: i32): i32
+@external('fastly_async_io', 'is_ready') declare function __fwd_ready(handle: i32, ready: usize): i32
+@external('fastly_http_resp', 'header_names_get')
+declare function __fwd_names(handle: i32, buffer: usize, size: i32, cursor: i32, end: usize, written: usize): i32
+@external('fastly_http_resp', 'header_values_get')
+declare function __fwd_values(handle: i32, name: usize, length: i32, buffer: usize, size: i32, cursor: i32, end: usize, written: usize): i32
+const __fwd_buffer: usize = memory.data(16384)
+const __fwd_headers: usize = memory.data(16384)
+const __fwd_pairs: usize = memory.data(1024) // 64 x (name ptr/size, value ptr/size)
+const __fwd_io: usize = memory.data(128) // aligned reusable ABI outputs
+let __fwd_source: i32 = -1
+let __fwd_upload: i32 = -1
+let __fwd_request: i32 = -1
+let __fwd_pending: i32 = -1
+let __fwd_response: i32 = -1
+let __fwd_body: i32 = -1
+let __fwd_downstream: i32 = -1
+let __fwd_output: i32 = -1
+let __fwd_index: i32 = -1
+let __fwd_result: i32 = 0
+let __fwd_marker: i32 = 0
+let __fwd_failure: i32 = 0
+let __fwd_committed: bool = false
+let __fwd_reserved: bool = false
+let __fwd_header_count: i32 = 0
+let __fwd_request_length: i32 = -1
+let __fwd_response_length: i32 = -1
+let __fwd_status: i32 = 200
+function host_request_body(): i32 {
+  if (__fwd_marker != 0 || __fwd_reserved) { __fwd_fail(400); return 0; }
+  const marker = new __PulseFastlyValue(); marker.kind = 90;
+  __fwd_marker = __pulse_fastly_put(marker); return __fwd_marker;
+}
+function __fwd_fail(status: i32): void {
+  if (__fwd_failure == 0) __fwd_failure = status;
+  __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 280, __fwd_index);
+}
+function __fwd_remaining(): i32 {
+  if (__fwd_failure != 0) return 0;
+  if (wasi_snapshot_preview1_clock_time_get(1, 1, __fwd_io) != 0) { __fwd_fail(504); return 0; }
+  const now = load<i64>(__fwd_io);
+  if (now < 0 || now < __request_last_clock || now < __pulse_fetch_last_clock) { __fwd_fail(504); return 0; }
+  __request_last_clock = now; __pulse_fetch_last_clock = now;
+  let remaining = f64(__request_deadline - now) / 1000000.0;
+  if (__request_expired || remaining <= 0) { __request_expired = true; __fwd_fail(504); return 0; }
+  if (__fwd_index >= 0) remaining = Math.min(remaining, __pulse_fetch_remaining(__fwd_index, now));
+  if (remaining <= 0) { __fwd_fail(504); return 0; }
+  return i32(Math.ceil(remaining)); // 1..30000; zero never reaches async.select
+}
+function __fwd_cleanup(): void {
+  if (__fwd_source >= 0) { __pulse_fetch_close_body(__fwd_source); __fwd_source = -1; }
+  if (__fwd_upload >= 0) { __fwd_abandon(__fwd_upload); __fwd_upload = -1; }
+  if (__fwd_request >= 0) { __pulse_fetch_close_request(__fwd_request); __fwd_request = -1; }
+  if (__fwd_body >= 0) { __pulse_fetch_close_body(__fwd_body); __fwd_body = -1; }
+  if (__fwd_response >= 0) { __pulse_fetch_close_response(__fwd_response); __fwd_response = -1; }
+  if (__fwd_output >= 0) { __pulse_fetch_close_response(__fwd_output); __fwd_output = -1; }
+  if (__fwd_downstream >= 0) { __fwd_abandon(__fwd_downstream); __fwd_downstream = -1; }
+  if (__fwd_pending >= 0) {
+    // No pending-request cancel ABI. Poll once without waiting and discard any
+    // late handles; an unresolved host operation ends at invocation teardown.
+    store<i32>(__fwd_io + 24, 0);
+    const status = __pulse_fetch_poll(__fwd_pending, __fwd_io + 8, __fwd_io + 24, __fwd_io + 28, __fwd_io + 32);
+    if (status == 0 && load<i32>(__fwd_io + 24) == 1) {
+      __pulse_fetch_close_response(load<i32>(__fwd_io + 28)); __pulse_fetch_close_body(load<i32>(__fwd_io + 32));
+    }
+    __fwd_pending = -1;
+  }
+}
+function __fwd_error_response(): bool {
+  if (__fwd_committed) { __fwd_cleanup(); return true; }
+  if (__fwd_failure == 0) return false;
+  const status = __fwd_failure;
+  __fwd_cleanup(); __request_error_response = true;
+  __pulse_fastly_last_error = 0;
+  const value = new __PulseFastlyValue(); value.kind = PULSE_VALUE_RESPONSE; value.status = status;
+  value.text = status == 413 ? 'Payload Too Large' : status == 504 ? 'Gateway Timeout' : status == 400 ? 'Bad Request' : 'Bad Gateway';
+  __fwd_committed = true;
+  __pulse_fastly_send_result(__pulse_fastly_put(value)); return true;
+}
+function __fwd_lower(byte: u8): u8 { return byte >= 65 && byte <= 90 ? byte + 32 : byte; }
+function __fwd_equal(ptr: usize, size: i32, text: string): bool {
+  if (size != text.length) return false;
+  for (let i = 0; i < size; i++) if (__fwd_lower(load<u8>(ptr + i)) != text.charCodeAt(i)) return false;
+  return true;
+}
+function __fwd_token(byte: u8): bool {
+  return (byte >= 48 && byte <= 57) || (byte >= 65 && byte <= 90) || (byte >= 97 && byte <= 122)
+    || byte == 33 || byte == 35 || byte == 36 || byte == 37 || byte == 38 || byte == 39 || byte == 42
+    || byte == 43 || byte == 45 || byte == 46 || byte == 94 || byte == 95 || byte == 96 || byte == 124 || byte == 126;
+}
+function __fwd_hop(ptr: usize, size: i32): bool {
+  return __fwd_equal(ptr,size,'connection') || __fwd_equal(ptr,size,'keep-alive') || __fwd_equal(ptr,size,'proxy-connection')
+    || __fwd_equal(ptr,size,'transfer-encoding') || __fwd_equal(ptr,size,'te') || __fwd_equal(ptr,size,'trailer')
+    || __fwd_equal(ptr,size,'upgrade') || __fwd_equal(ptr,size,'content-length') || __fwd_equal(ptr,size,'host')
+    || __fwd_equal(ptr,size,'proxy-authenticate') || __fwd_equal(ptr,size,'proxy-authorization');
+}
+// Decimal parsing stops at cap+1: huge declared sizes cannot overflow or wrap.
+function __fwd_length(ptr: usize, size: i32, cap: i32): i32 {
+  if (size == 0) return -2;
+  let value = 0;
+  for (let i = 0; i < size; i++) {
+    const byte = load<u8>(ptr + i); if (byte < 48 || byte > 57) return -2;
+    value = min(cap + 1, value * 10 + byte - 48);
+  }
+  return value;
+}
+function __fwd_declared_request(): bool {
+  const name = memory.data<u8>([99,111,110,116,101,110,116,45,108,101,110,103,116,104]);
+  store<i64>(__fwd_io + 40, -1); store<i32>(__fwd_io + 48, 0);
+  const status = __pulse_request_header_values(__pulse_fastly_request_handle, name, 14, __fwd_headers, 16384, 0, __fwd_io + 40, __fwd_io + 48);
+  const count = load<i32>(__fwd_io + 48);
+  if (status != 0 || count < 0 || count > 16384 || (count > 0 && load<i64>(__fwd_io + 40) != -1)) { __fwd_fail(400); return false; }
+  if (count == 0) return true;
+  if (load<u8>(__fwd_headers + count - 1) != 0) { __fwd_fail(400); return false; }
+  __fwd_request_length = __fwd_length(__fwd_headers, count - 1, __FWD_REQUEST_MAX);
+  if (__fwd_request_length < 0) { __fwd_fail(400); return false; }
+  if (__fwd_request_length > __FWD_REQUEST_MAX) { __fwd_fail(413); return false; }
+  return true;
+}
+function __fwd_begin(index: i32, payload: __PulseFastlyValue): void {
+  __fwd_index = index;
+  const init = __pulse_fastly_value(__pulse_fastly_payload_field(payload, 'init'));
+  if (__fwd_reserved || __fwd_source < 0 || __pulse_fastly_payload_field(init, 'body') != __fwd_marker || __fwd_marker == 0) { __fwd_fail(400); return; }
+  __fwd_reserved = true;
+  __pulse_fetch_begin_deadline(index, init);
+  if (__pulse_fastly_last_error != 0 || !__fwd_remaining() || !__fwd_declared_request()) return;
+  const url = __pulse_fastly_utf8(__pulse_fastly_string(__pulse_fastly_payload_field(payload, 'url')));
+  const backend = __pulse_fastly_utf8(__pulse_fastly_backend(index));
+  if (fastly_http_req_new(__fwd_io + 52) != 0) { __fwd_fail(502); return; }
+  __fwd_request = load<i32>(__fwd_io + 52);
+  if (fastly_http_body_new(__fwd_io + 52) != 0) { __fwd_fail(502); return; }
+  __fwd_upload = load<i32>(__fwd_io + 52);
+  const method = memory.data<u8>([80,79,83,84]);
+  if (fastly_http_req_method_set(__fwd_request, method, 4) != 0 || fastly_http_req_uri_set(__fwd_request, changetype<usize>(url), url.byteLength) != 0) { __fwd_fail(502); return; }
+  const headers = __pulse_fastly_value(__pulse_fastly_payload_field(init, 'headers'));
+  let bytes = 0;
+  if (headers.kind == PULSE_VALUE_OBJECT) for (let i = 0; i < headers.keys.length; i++) {
+    const name = __pulse_fastly_utf8(headers.keys[i]), value = __pulse_fastly_utf8(__pulse_fastly_string(headers.values[i]));
+    bytes += name.byteLength + value.byteLength + 4;
+    if (i >= 64 || bytes > 16384 || __fwd_hop(changetype<usize>(name), name.byteLength)) { __fwd_fail(400); return; }
+    if (fastly_http_req_header_insert(__fwd_request, changetype<usize>(name), name.byteLength, changetype<usize>(value), value.byteLength) != 0) { __fwd_fail(400); return; }
+  }
+  if (!__fwd_remaining()) return;
+  const status = __fwd_dispatch(__fwd_request, __fwd_upload, changetype<usize>(backend), backend.byteLength, __fwd_io + 52);
+  // send may consume the request even on failure. Cleanup makes only a best-effort
+  // close on that error path before any handle allocation/reuse can occur.
+  if (status != 0) { __fwd_fail(502); return; }
+  __fwd_request = -1; __fwd_pending = load<i32>(__fwd_io + 52);
+  __pulse_fastly_pending[index] = __fwd_pending; __pulse_fastly_pending_mode[index] = PULSE_FASTLY_PENDING_ASYNC;
+  __fwd_remaining();
+}
+// Adopt early headers before considering readiness of the source or writer.
+function __fwd_poll(): bool {
+  if (__fwd_pending < 0 || !__fwd_remaining()) return __fwd_response >= 0;
+  store<i32>(__fwd_io + 24, 0);
+  const status = __pulse_fetch_poll(__fwd_pending, __fwd_io + 8, __fwd_io + 24, __fwd_io + 28, __fwd_io + 32);
+  const done = load<i32>(__fwd_io + 24);
+  if (status != 0) { __fwd_pending = -1; __fwd_fail(502); return false; }
+  if (done != 0 && done != 1) { __fwd_fail(502); return false; }
+  if (done == 1) {
+    __fwd_response = load<i32>(__fwd_io + 28); __fwd_body = load<i32>(__fwd_io + 32); __fwd_pending = -1;
+  }
+  if (!__fwd_remaining()) return false;
+  return done == 1;
+}
+function __fwd_wait_io(handle: i32, upload: bool): bool {
+  while (__fwd_remaining() > 0) {
+    if (upload && __fwd_poll()) return false;
+    if (__fwd_failure != 0) return false;
+    store<i32>(__fwd_io + 52, -1);
+    if (__fwd_ready(handle, __fwd_io + 52) != 0) { __fwd_fail(502); return false; }
+    const ready = load<i32>(__fwd_io + 52);
+    if (ready == 1) return __fwd_remaining() > 0;
+    if (ready != 0) { __fwd_fail(502); return false; }
+    let count = 0;
+    if (upload && __fwd_pending >= 0) { store<i32>(__fwd_io + 56, __fwd_pending); count++; }
+    store<i32>(__fwd_io + 56 + count * 4, handle); count++;
+    const remaining = __fwd_remaining(); if (remaining == 0) return false;
+    const status = __pulse_fetch_select(__fwd_io + 56, count, remaining, __fwd_io + 64);
+    if (status != 0) { __fwd_fail(502); return false; }
+    const selected = load<i32>(__fwd_io + 64);
+    if (selected == -1) { __fwd_fail(504); return false; }
+    if (selected < 0 || selected >= count) { __fwd_fail(502); return false; }
+  }
+  return false;
+}
+function __fwd_copy(source: i32, sink: i32, cap: i32, declared: i32, upload: bool): bool {
+  let total = 0;
+  while (true) {
+    // Demand first; at most one raw chunk can be read ahead of the writer.
+    if (!__fwd_wait_io(sink, upload) || !__fwd_wait_io(source, upload)) return false;
+    const size = min(16384, cap - total + 1);
+    store<i32>(__fwd_io + 68, -1);
+    if (fastly_http_body_read(source, __fwd_buffer, size, __fwd_io + 68) != 0) { __fwd_fail(upload ? 400 : 502); return false; }
+    const read = load<i32>(__fwd_io + 68);
+    if (!__fwd_remaining()) return false;
+    if (read < 0 || read > size) { __fwd_fail(502); return false; }
+    if (read == 0) {
+      if (declared >= 0 && total != declared) { __fwd_fail(upload ? 400 : 502); return false; }
+      return true;
+    }
+    total += read;
+    if (total > cap) { __fwd_fail(upload ? 413 : 502); return false; }
+    if (declared >= 0 && total > declared) { __fwd_fail(upload ? 400 : 502); return false; }
+    let offset = 0;
+    while (offset < read) {
+      if (!__fwd_wait_io(sink, upload)) return false;
+      store<i32>(__fwd_io + 72, -1);
+      if (fastly_http_body_write(sink, __fwd_buffer + offset, read - offset, 0, __fwd_io + 72) != 0) { __fwd_fail(502); return false; }
+      const written = load<i32>(__fwd_io + 72);
+      if (!__fwd_remaining()) return false;
+      if (written <= 0 || written > read - offset) { __fwd_fail(502); return false; }
+      offset += written;
+    }
+  }
+}
+function __fwd_wait(): i32 {
+  if (__fwd_failure != 0 || __fwd_pending < 0) return 0;
+  const eof = __fwd_copy(__fwd_source, __fwd_upload, __FWD_REQUEST_MAX, __fwd_request_length, true);
+  __pulse_fetch_close_body(__fwd_source); __fwd_source = -1;
+  if (eof && __fwd_remaining()) {
+    const upload = __fwd_upload; __fwd_upload = -1;
+    if (__pulse_fetch_close_body(upload) != 0) __fwd_fail(502);
+  } else if (__fwd_upload >= 0) { __fwd_abandon(__fwd_upload); __fwd_upload = -1; }
+  while (__fwd_failure == 0 && __fwd_response < 0) {
+    if (__fwd_poll()) break;
+    if (__fwd_failure != 0 || !__fwd_wait_io(__fwd_pending, false)) break;
+  }
+  __pulse_fastly_pending_mode[__fwd_index] = PULSE_FASTLY_PENDING_NONE; __pulse_fastly_pending[__fwd_index] = 0;
+  if (__fwd_failure != 0 || !__fwd_remaining()) return 0;
+  const value = new __PulseFastlyValue(); value.kind = PULSE_VALUE_FETCH;
+  value.responseHandle = __fwd_response; value.bodyHandle = __fwd_body;
+  __fwd_result = __pulse_fastly_put(value); return __fwd_result;
+}
+function __fwd_response_headers(): bool {
+  store<i32>(__fwd_io + 52, 0);
+  if (fastly_http_resp_status_get(__fwd_response, __fwd_io + 52) != 0) { __fwd_fail(502); return false; }
+  __fwd_status = load<u16>(__fwd_io + 52);
+  if (__fwd_status < 200 || __fwd_status > 599) { __fwd_fail(502); return false; }
+  store<i64>(__fwd_io + 40, -1); store<i32>(__fwd_io + 48, -1);
+  if (__fwd_names(__fwd_response, __fwd_headers, 16384, 0, __fwd_io + 40, __fwd_io + 48) != 0) { __fwd_fail(502); return false; }
+  const names = load<i32>(__fwd_io + 48);
+  if (names < 0 || names > 16384 || (names > 0 && load<i64>(__fwd_io + 40) != -1)) { __fwd_fail(502); return false; }
+  let used = names, start = 0, total = 0, nameCount = 0;
+  for (let i = 0; i < names; i++) {
+    const byte = load<u8>(__fwd_headers + i);
+    if (byte != 0) { if (!__fwd_token(byte)) { __fwd_fail(502); return false; } continue; }
+    const name = __fwd_headers + start, length = i - start; start = i + 1;
+    if (length == 0 || ++nameCount > 64 || used >= 16384) { __fwd_fail(502); return false; }
+    store<i64>(__fwd_io + 40, -1); store<i32>(__fwd_io + 48, -1);
+    if (__fwd_values(__fwd_response, name, length, __fwd_headers + used, 16384 - used, 0, __fwd_io + 40, __fwd_io + 48) != 0) { __fwd_fail(502); return false; }
+    const size = load<i32>(__fwd_io + 48);
+    if (size <= 0 || size > 16384 - used || load<i64>(__fwd_io + 40) != -1) { __fwd_fail(502); return false; }
+    let valueStart = 0;
+    for (let j = 0; j < size; j++) {
+      const item = load<u8>(__fwd_headers + used + j);
+      if (item != 0) { if ((item < 32 && item != 9) || item == 127) { __fwd_fail(502); return false; } continue; }
+      const value = __fwd_headers + used + valueStart, valueSize = j - valueStart; valueStart = j + 1;
+      total += length + valueSize + 4;
+      if (__fwd_header_count >= 64 || total > 16384) { __fwd_fail(502); return false; }
+      const pair = __fwd_pairs + __fwd_header_count * 16; __fwd_header_count++;
+      store<usize>(pair, name); store<i32>(pair + 4, length); store<usize>(pair + 8, value); store<i32>(pair + 12, valueSize);
+      if (__fwd_equal(name, length, 'content-length')) {
+        if (__fwd_response_length != -1) { __fwd_fail(502); return false; }
+        __fwd_response_length = __fwd_length(value, valueSize, __FWD_RESPONSE_MAX);
+        if (__fwd_response_length < 0 || (__fwd_status != 304 && __fwd_response_length > __FWD_RESPONSE_MAX)) { __fwd_fail(502); return false; }
+      }
+    }
+    if (valueStart != size) { __fwd_fail(502); return false; }
+    used += size;
+  }
+  if (start != names || ((__fwd_status == 204 || __fwd_status == 205) && __fwd_response_length > 0)) { __fwd_fail(502); return false; }
+  return __fwd_remaining() > 0;
+}
+function __fwd_nominated(name: usize, length: i32): bool {
+  let nominated = false;
+  for (let i = 0; i < __fwd_header_count; i++) {
+    const pair = __fwd_pairs + i * 16;
+    if (!__fwd_equal(load<usize>(pair), load<i32>(pair + 4), 'connection')) continue;
+    const value = load<usize>(pair + 8), size = load<i32>(pair + 12);
+    let offset = 0;
+    while (offset < size) {
+      while (offset < size && (load<u8>(value + offset) == 32 || load<u8>(value + offset) == 9)) offset++;
+      const start = offset;
+      while (offset < size && __fwd_token(load<u8>(value + offset))) offset++;
+      const count = offset - start;
+      if (count == 0) { __fwd_fail(502); return false; }
+      if (count == length) {
+        let same = true;
+        for (let c = 0; c < count; c++) if (__fwd_lower(load<u8>(value + start + c)) != __fwd_lower(load<u8>(name + c))) same = false;
+        if (same) nominated = true;
+      }
+      while (offset < size && (load<u8>(value + offset) == 32 || load<u8>(value + offset) == 9)) offset++;
+      if (offset < size && (load<u8>(value + offset++) != 44 || offset == size)) { __fwd_fail(502); return false; }
+    }
+  }
+  return nominated;
+}
+function __fwd_send(): i32 {
+  if (!__fwd_response_headers()) { __fwd_error_response(); return 0; }
+  if (fastly_http_resp_new(__fwd_io + 52) != 0) { __fwd_fail(502); __fwd_error_response(); return 0; }
+  __fwd_output = load<i32>(__fwd_io + 52);
+  if (fastly_http_resp_status_set(__fwd_output, __fwd_status) != 0 || fastly_http_body_new(__fwd_io + 52) != 0) { __fwd_fail(502); __fwd_error_response(); return 0; }
+  __fwd_downstream = load<i32>(__fwd_io + 52);
+  for (let i = 0; i < __fwd_header_count; i++) {
+    const pair = __fwd_pairs + i * 16, name = load<usize>(pair), length = load<i32>(pair + 4);
+    const nominated = __fwd_nominated(name, length);
+    if (__fwd_failure != 0) break;
+    if (__fwd_hop(name, length) || nominated) continue;
+    if (fastly_http_resp_header_append(__fwd_output, name, length, load<usize>(pair + 8), load<i32>(pair + 12)) != 0) { __fwd_fail(502); break; }
+  }
+  __pulse_fetch_close_response(__fwd_response); __fwd_response = -1;
+  if (!__fwd_remaining()) { __fwd_error_response(); return 0; }
+  // Treat even an ambiguous send failure as committed: never emit a second
+  // response. The writable body remains ours until explicit EOF or abandon.
+  __fwd_committed = true;
+  const output = __fwd_output; __fwd_output = -1;
+  if (fastly_http_resp_send_downstream(output, __fwd_downstream, 1) != 0) { __pulse_fetch_close_response(output); __fwd_fail(502); __fwd_cleanup(); return 0; }
+  const bodyless = __fwd_status == 204 || __fwd_status == 205 || __fwd_status == 304;
+  const eof = __fwd_copy(__fwd_body, __fwd_downstream, bodyless ? 0 : __FWD_RESPONSE_MAX, bodyless ? 0 : __fwd_response_length, false);
+  __pulse_fetch_close_body(__fwd_body); __fwd_body = -1;
+  if (eof && __fwd_remaining()) {
+    const downstream = __fwd_downstream; __fwd_downstream = -1;
+    if (__pulse_fetch_close_body(downstream) != 0) __fwd_fail(502);
+    // Success is the host-handoff boundary. The handle is gone; there is no
+    // final-writer wait, delivery receipt, or post-handoff timeout guarantee.
+  }
+  __fwd_cleanup(); return 0;
+}

package/src/build/native-body-forwarding.js

@@ -0,0 +1,69 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const {normalizeBodyForwarding, forwardingError} = require('../toolchain/body-forwarding.js');
+const IMPORTS = ['fastly_http_req:send_async_streaming', 'fastly_http_body:abandon',
+  'fastly_async_io:is_ready', 'fastly_http_resp:header_names_get'];
+const enabled = plan => (plan?.capabilities || []).includes('request.body.forward');
+function field(value, name) { return value?.entries?.find(entry => entry.key?.value === name)?.value; }
+function validate(plan, options) {
+  const config = normalizeBodyForwarding(options.bodyForwarding, options.maxDurationMs);
+  if (!enabled(plan)) return;
+  if (!config) throw forwardingError('Fastly Native incoming forwarding requires fastly.bodyForwarding limits and maxDurationMs.');
+  const effects = plan.effects || [], effect = effects[0];
+  const init = effect?.inputs?.find(input => input.name === 'init')?.value;
+  const body = field(init, 'body'), method = field(init, 'method'), headers = field(init, 'headers');
+  if (effects.length !== 1 || effect.kind !== 'fetch' || effect.grouped
+    || effect.result?.mode !== 'return' || effect.result?.valueKind !== 'opaque-response'
+    || effect.resource?.kind !== 'literal' || options.bindings?.dynamicBackends
+    || body?.name !== 'request.body.forward-marker' || method?.kind !== 'literal' || method.value !== 'POST'
+    || init.entries.some(entry => !['method', 'body', 'headers', 'timeoutMs'].includes(entry.key?.value))
+    || (headers && (headers.kind !== 'object' || headers.entries.some(entry => entry.key?.kind !== 'literal' || entry.value?.kind !== 'literal' || typeof entry.value.value !== 'string')))) {
+    throw forwardingError('Fastly Native forwarding admits one terminal opaque POST fetch with inline req.body(), a static backend, and optional literal headers/timeoutMs; groups, decoding, reuse, and dynamic backends are unsupported.');
+  }
+  const entries = headers?.entries || [];
+  const hop = /^(connection|keep-alive|proxy-connection|transfer-encoding|te|trailer|upgrade|content-length|host|proxy-authenticate|proxy-authorization)$/i;
+  if (entries.length > 64 || entries.reduce((sum, entry) => sum + Buffer.byteLength(entry.key.value) + Buffer.byteLength(entry.value.value) + 4, 0) > 16384
+    || entries.some(entry => hop.test(entry.key.value) || !/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(entry.key.value) || /[\x00-\x08\x0a-\x1f\x7f]/.test(entry.value.value))) {
+    throw forwardingError('Forwarding request headers must fit 64 pairs/16 KiB and exclude hop-by-hop, framing and Host fields.');
+  }
+  // One marker evaluation owns the incoming body. Reject unused/duplicate markers
+  // too: they must not be dispatched later through another continuation.
+  let markers = 0;
+  function walk(value) { if (!value || typeof value !== 'object') return; if (value.name === 'request.body.forward-marker') markers++; for (const item of Object.values(value)) walk(item); }
+  walk(plan);
+  if (markers !== 1) throw forwardingError('Fastly Native forwarding requires exactly one incoming body consumer.');
+}
+function instrument(input, plan, bindings) {
+  if (!enabled(plan)) return input;
+  let source = input;
+  const replace = (before, after) => {
+    if (!source.includes(before)) throw new Error('Fastly body-forwarding boundary drift: ' + before.slice(0, 100));
+    source = source.replace(before, after);
+  };
+  for (const [name, args, result, body] of [
+    ['__pulse_fastly_fetch_begin', 'effectIndex: i32, payload: __PulseFastlyValue', 'void', '__fwd_begin(effectIndex, payload);'],
+    ['__pulse_fastly_wait_fetch', 'effectIndex: i32', 'i32', 'return __fwd_wait();']
+  ]) {
+    const line = source.split('\n').find(line => line.startsWith(`function ${name}(`));
+    if (!line || !line.endsWith('}')) throw new Error('Fastly forwarding function boundary drift: ' + name);
+    replace(line, `function ${name}(${args}): ${result} { ${body} }`);
+  }
+  replace('function __pulse_fastly_send_result(handle: i32): i32 {',
+    'function __pulse_fastly_send_result(handle: i32): i32 { if (handle == __fwd_result && handle != 0) return __fwd_send();');
+  replace('function __pulse_fastly_jwt_send_error(): void {',
+    'function __pulse_fastly_jwt_send_error(): void { if (__fwd_error_response()) return;');
+  replace('function __request_send_timeout(): void {',
+    'function __request_send_timeout(): void { if (__fwd_committed) { __fwd_cleanup(); return; }');
+  replace('  __pulse_fastly_run_invocation()\n', '  __pulse_fastly_run_invocation()\n  __fwd_cleanup()\n');
+  replace('  __pulse_fastly_request_body_handle = load<i32>(changetype<usize>(handles) + 4)',
+    '  __pulse_fastly_request_body_handle = load<i32>(changetype<usize>(handles) + 4)\n  __fwd_source = __pulse_fastly_request_body_handle');
+  // Generic request-budget code must not wait for headers before driving upload.
+  const begin = source.indexOf('function __pulse_fastly_resolve_effect(');
+  const end = source.indexOf('\n}', begin);
+  if (begin < 0 || end < 0) throw new Error('Fastly forwarding effect boundary drift');
+  source = source.slice(0, begin) + 'function __pulse_fastly_resolve_effect(effectIndex: i32): i32 { return __fwd_wait(); }' + source.slice(end + 2);
+  return source + '\n' + `const __FWD_REQUEST_MAX: i32 = ${bindings.bodyForwarding.requestMaxBytes}\nconst __FWD_RESPONSE_MAX: i32 = ${bindings.bodyForwarding.responseMaxBytes}\n`
+    + fs.readFileSync(path.join(__dirname, 'native-body-forwarding.as.ts'), 'utf8');
+}
+module.exports = {IMPORTS, enabled, validate, instrument};

package/src/build/native-fetch-deadlines.as.ts

@@ -0,0 +1,161 @@
+// Per-invocation, per-admission header deadlines. A reused effect site gets a new
+// clock sample; waiting on an earlier group member cannot replenish this budget.
+@external('fastly_async_io', 'select')
+declare function __pulse_fetch_select(handles: usize, count: i32, timeout: i32, done: usize): i32
+@external('fastly_http_req', 'pending_req_poll_v2')
+declare function __pulse_fetch_poll(handle: i32, detail: usize, done: usize, response: usize, body: usize): i32
+@external('fastly_http_resp', 'close')
+declare function __pulse_fetch_close_response(handle: i32): i32
+const __pulse_fetch_timeout = new StaticArray<f64>(PULSE_FASTLY_EFFECT_COUNT)
+const __pulse_fetch_started = new StaticArray<i64>(PULSE_FASTLY_EFFECT_COUNT)
+const __pulse_fetch_completed = new StaticArray<bool>(PULSE_FASTLY_EFFECT_COUNT)
+// Zero = headers, positive = Fastly status, -1 = timeout, -2 = protocol/clock.
+const __pulse_fetch_outcome = new StaticArray<i32>(PULSE_FASTLY_EFFECT_COUNT)
+const __pulse_fetch_retired = new Array<i32>()
+let __pulse_fetch_last_clock: i64 = -1
+let __pulse_fetch_retired_total: i32 = 0
+export function pulse_fastly_fetch_retired(): i32 { return __pulse_fetch_retired_total }
+export function pulse_fastly_fetch_unreaped(): i32 { return __pulse_fetch_retired.length }
+function __pulse_fetch_clock(index: i32): i64 {
+  const out = new StaticArray<i64>(1)
+  if (wasi_snapshot_preview1_clock_time_get(1, 1, changetype<usize>(out)) != 0
+    || out[0] < 0 || out[0] < __pulse_fetch_last_clock) {
+    __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 272, index); return -1
+  }
+  __pulse_fetch_last_clock = out[0]; return out[0]
+}
+function __pulse_fetch_begin_deadline(index: i32, init: __PulseFastlyValue): void {
+  __pulse_fetch_timeout[index] = 0; __pulse_fetch_completed[index] = false; __pulse_fetch_outcome[index] = 0
+  const field = __pulse_fastly_find(init, 'timeoutMs')
+  if (field < 0) return
+  const value = __pulse_fastly_value(unchecked(init.values[field]))
+  if (value.kind == PULSE_VALUE_UNDEFINED) return
+  const ms = value.number
+  if (value.kind != PULSE_VALUE_NUMBER || ms <= 0 || ms > 9007199254740991 || Math.floor(ms) != ms) {
+    __pulse_fastly_fail(PULSE_ERROR_VALUE, 270, index); return
+  }
+  __pulse_fetch_timeout[index] = ms
+  __pulse_fetch_started[index] = __pulse_fetch_clock(index)
+}
+function __pulse_fetch_remaining(index: i32, now: i64): f64 {
+  if (__pulse_fetch_timeout[index] == 0) return 2147483647.0
+  // Subtract elapsed nanoseconds before converting. Do not overflow by adding
+  // a safe-integer millisecond option to an i64 nanosecond clock.
+  return __pulse_fetch_timeout[index] - f64(now - __pulse_fetch_started[index]) / 1000000.0
+}
+function __pulse_fetch_before_send(index: i32): bool {
+  if (__pulse_fastly_effect_kind(index) != 1 || __pulse_fetch_timeout[index] == 0) return true
+  const now = __pulse_fetch_clock(index)
+  if (now < 0) return false
+  if (__pulse_fetch_remaining(index, now) > 0) return true
+  __pulse_fastly_fail(PULSE_ERROR_TRANSPORT, 271, index); return false
+}
+function __pulse_fetch_active(index: i32): bool {
+  return __pulse_fastly_effect_kind(index) == 1 && __pulse_fastly_pending_mode[index] == PULSE_FASTLY_PENDING_ASYNC
+}
+function __pulse_fetch_has_deadlines(): bool {
+  for (let i = 0; i < PULSE_FASTLY_EFFECT_COUNT; i++)
+    if (__pulse_fetch_active(i) && __pulse_fetch_timeout[i] > 0) return true
+  return false
+}
+function __pulse_fetch_complete(index: i32, outcome: i32, result: i32 = 0): void {
+  __pulse_fastly_pending_mode[index] = PULSE_FASTLY_PENDING_READY
+  __pulse_fastly_pending[index] = 0; __pulse_fastly_ready[index] = result
+  __pulse_fetch_completed[index] = true; __pulse_fetch_outcome[index] = outcome
+}
+function __pulse_fetch_retire(index: i32, outcome: i32): void {
+  // The Fastly ABI has no pending-request cancellation hostcall. Retain explicit
+  // ownership until invocation cleanup; never wait, retry, or claim rollback.
+  __pulse_fetch_retired.push(__pulse_fastly_pending[index]); __pulse_fetch_retired_total++
+  __pulse_fetch_complete(index, outcome)
+}
+function __pulse_fetch_retire_all(): void {
+  for (let i = 0; i < PULSE_FASTLY_EFFECT_COUNT; i++) if (__pulse_fetch_active(i)) __pulse_fetch_retire(i, -2)
+}
+function __pulse_fetch_reap(): void {
+  const detail = new StaticArray<i32>(4), done = new StaticArray<i32>(1)
+  const response = new StaticArray<i32>(1), body = new StaticArray<i32>(1)
+  for (let i = __pulse_fetch_retired.length - 1; i >= 0; i--) {
+    done[0] = 0
+    const status = __pulse_fetch_poll(__pulse_fetch_retired[i], changetype<usize>(detail), changetype<usize>(done), changetype<usize>(response), changetype<usize>(body))
+    if (status == 0 && done[0] == 0) continue
+    if (status == 0 && done[0] == 1) { __pulse_fetch_close_response(response[0]); __pulse_fetch_close_body(body[0]) }
+    __pulse_fetch_retired[i] = __pulse_fetch_retired[__pulse_fetch_retired.length - 1]; __pulse_fetch_retired.pop()
+  }
+  // Unready handles remain platform-owned until host teardown. No guest task
+  // survives _start and no response/body is exposed for an expired operation.
+}
+// Request-budget instrumentation replaces these hooks when maxDurationMs exists.
+function __pulse_fetch_request_check(index: i32): bool { return true }
+function __pulse_fetch_request_remaining(): i32 { return 2147483647 }
+function __pulse_fetch_take(index: i32): i32 {
+  const outcome = __pulse_fetch_outcome[index], result = __pulse_fastly_ready[index]
+  __pulse_fetch_completed[index] = false; __pulse_fastly_pending_mode[index] = PULSE_FASTLY_PENDING_NONE
+  __pulse_fastly_ready[index] = 0
+  if (outcome == -1) __pulse_fastly_fail(PULSE_ERROR_TRANSPORT, 271, index)
+  else if (outcome == -2) __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 272, index)
+  else if (outcome != 0) __pulse_fetch_fail(outcome, 81, index)
+  return outcome == 0 ? result : 0
+}
+function __pulse_fetch_wait(index: i32): i32 {
+  const handles = new StaticArray<i32>(PULSE_FASTLY_EFFECT_COUNT), selected = new StaticArray<i32>(1)
+  const detail = new StaticArray<i32>(4), done = new StaticArray<i32>(1)
+  const response = new StaticArray<i32>(1), body = new StaticArray<i32>(1)
+  while (!__pulse_fetch_completed[index]) {
+    if (!__pulse_fetch_request_check(index)) { __pulse_fetch_retire_all(); return 0 }
+    let now = __pulse_fetch_clock(index)
+    if (now < 0) { __pulse_fetch_retire_all(); return 0 }
+    let count = 0, remaining = 2147483647.0
+    // Observe all dispatched fetches, not just the first static slot. Otherwise
+    // a slow earlier sibling could turn timely later headers into a false timeout.
+    for (let i = 0; i < PULSE_FASTLY_EFFECT_COUNT; i++) {
+      if (!__pulse_fetch_active(i)) continue
+      if (__pulse_fetch_remaining(i, now) <= 0) { __pulse_fetch_retire(i, -1); continue }
+      done[0] = 0
+      const status = __pulse_fetch_poll(__pulse_fastly_pending[i], changetype<usize>(detail), changetype<usize>(done), changetype<usize>(response), changetype<usize>(body))
+      now = __pulse_fetch_clock(i)
+      if (status != 0) {
+        __pulse_fetch_complete(i, now < 0 ? -2 : __pulse_fetch_remaining(i, now) <= 0 ? -1 : status)
+        if (now < 0) { __pulse_fetch_retire_all(); return 0 }
+        continue
+      }
+      if (done[0] != 0 && done[0] != 1) {
+        __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 272, i); __pulse_fetch_retire_all(); return 0
+      }
+      if (now < 0 || __pulse_fetch_remaining(i, now) <= 0) {
+        if (done[0] == 1) {
+          __pulse_fetch_close_response(response[0]); __pulse_fetch_close_body(body[0]); __pulse_fetch_complete(i, now < 0 ? -2 : -1)
+        } else __pulse_fetch_retire(i, now < 0 ? -2 : -1)
+        if (now < 0) { __pulse_fetch_retire_all(); return 0 }
+        continue
+      }
+      if (done[0] == 1) {
+        const value = new __PulseFastlyValue(); value.kind = PULSE_VALUE_FETCH
+        value.responseHandle = response[0]; value.bodyHandle = body[0]
+        __pulse_fetch_complete(i, 0, __pulse_fastly_put(value)); continue
+      }
+    }
+    if (__pulse_fetch_completed[index]) break
+    if (!__pulse_fetch_request_check(index)) { __pulse_fetch_retire_all(); return 0 }
+    now = __pulse_fetch_clock(index)
+    if (now < 0) { __pulse_fetch_retire_all(); return 0 }
+    for (let i = 0; i < PULSE_FASTLY_EFFECT_COUNT; i++) {
+      if (!__pulse_fetch_active(i)) continue
+      const budget = __pulse_fetch_remaining(i, now)
+      if (budget <= 0) { __pulse_fetch_retire(i, -1); continue }
+      handles[count++] = __pulse_fastly_pending[i]; remaining = Math.min(remaining, budget)
+    }
+    if (__pulse_fetch_completed[index]) break
+    remaining = Math.min(remaining, f64(__pulse_fetch_request_remaining()))
+    if (count == 0 || remaining <= 0) {
+      __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 272, index); __pulse_fetch_retire_all(); return 0
+    }
+    selected[0] = -2
+    const status = __pulse_fetch_select(changetype<usize>(handles), count, i32(Math.ceil(remaining)), changetype<usize>(selected))
+    const after = __pulse_fetch_clock(index)
+    if (status != 0 || selected[0] < -1 || selected[0] >= count || after < 0 || (selected[0] == -1 && after <= now)) {
+      __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 272, index); __pulse_fetch_retire_all(); return 0
+    }
+  }
+  return __pulse_fetch_take(index)
+}

package/src/build/native-fetch-deadlines.js

@@ -0,0 +1,27 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+function enabled(plan) { return (plan.effects || []).some(effect => effect.kind === 'fetch'); }
+function runtimeSource(plan) {
+  if (!enabled(plan)) return `function __pulse_fetch_has_deadlines(): bool { return false }
+function __pulse_fetch_request_check(index: i32): bool { return true }
+function __pulse_fetch_request_remaining(): i32 { return 2147483647 }`;
+  return fs.readFileSync(path.join(__dirname,'native-fetch-deadlines.as.ts'),'utf8');
+}
+function instrument(input, plan) {
+  if (!enabled(plan)) return input;
+  let source = input;
+  const replace = (before,after) => {
+    if (!source.includes(before)) throw new Error('Fastly fetch deadline boundary drift: ' + before.slice(0,80));
+    source = source.replace(before,after);
+  };
+  replace('const init = initIndex >= 0 ? __pulse_fastly_value(unchecked(payload.values[initIndex])) : new __PulseFastlyValue(); let method',
+    'const init = initIndex >= 0 ? __pulse_fastly_value(unchecked(payload.values[initIndex])) : new __PulseFastlyValue(); __pulse_fetch_begin_deadline(effectIndex, init); if (__pulse_fastly_last_error != 0) return; let method');
+  replace('const backendBytes = __pulse_fastly_utf8(backend); const pendingOut',
+    'if (!__pulse_fetch_before_send(effectIndex)) { __pulse_fetch_close_request(requestHandle); __pulse_fetch_close_body(bodyHandle); return; } const backendBytes = __pulse_fastly_utf8(backend); const pendingOut');
+  replace('function __pulse_fastly_wait_fetch(effectIndex: i32): i32 {',
+    'function __pulse_fastly_wait_fetch(effectIndex: i32): i32 { if (__pulse_fastly_effect_kind(effectIndex) == 1 && (__pulse_fetch_completed[effectIndex] || __pulse_fetch_has_deadlines())) return __pulse_fetch_wait(effectIndex);');
+  replace('function __pulse_invocation_close(): void {', 'function __pulse_invocation_close(): void { __pulse_fetch_reap();');
+  return source;
+}
+module.exports = {runtimeSource,instrument};

package/src/build/native-fetch-errors.js

@@ -0,0 +1,40 @@
+'use strict';
+
+function runtimeSource() {
+  return `
+@external("fastly_http_req", "close")
+declare function __pulse_fetch_close_request(handle: i32): i32
+@external("fastly_http_body", "close")
+declare function __pulse_fetch_close_body(handle: i32): i32
+function __pulse_fetch_fail(status: i32, stage: i32, effect: i32): void {
+  // Fastly ERROR and HTTP parse/user/incomplete/size/status errors represent
+  // failed exchanges. Invalid arguments, handles and unsupported ABI stay fatal.
+  const network = __pulse_fastly_effect_kind(effect) != 1 || status == 1 || status == 7 || status == 8 || status == 9 || status == 11 || status == 12;
+  __pulse_fastly_fail(network ? PULSE_ERROR_TRANSPORT : PULSE_ERROR_HOSTCALL, stage, effect);
+}
+function __pulse_fetch_failed(): bool {
+  return (__pulse_fastly_last_error == PULSE_ERROR_TRANSPORT || __pulse_fastly_last_error == PULSE_ERROR_HOSTCALL || __pulse_fastly_last_error == PULSE_ERROR_VALUE)
+    && (__pulse_fastly_error_stage == 77 || __pulse_fastly_error_stage == 81 || (__pulse_fastly_error_stage >= 270 && __pulse_fastly_error_stage <= 272))
+    && __pulse_fastly_effect_kind(__pulse_fastly_error_effect) == 1;
+}
+function __pulse_fetch_send_error(): bool {
+  if (!__pulse_fetch_failed()) return false;
+  const output = new __PulseFastlyValue(); output.kind = PULSE_VALUE_RESPONSE;
+  const network = __pulse_fastly_last_error == PULSE_ERROR_TRANSPORT;
+  output.status = __pulse_fastly_error_stage == 270 ? 400 : __pulse_fastly_error_stage == 271 ? 504 : network ? 502 : 500;
+  output.text = __pulse_fastly_error_stage == 270 ? "Invalid fetch timeoutMs" : __pulse_fastly_error_stage == 271 ? "Gateway Timeout" : network ? "Bad Gateway" : "Internal Server Error";
+  output.headers.push(new __PulseFastlyHeader("content-type", "text/plain; charset=utf-8"));
+  __pulse_fastly_send_result(__pulse_fastly_put(output));
+  return true;
+}
+`;
+}
+function instrument(source) {
+  // Keep the fatal marker for the deadline owner, which runs after this pass.
+  source = source.replace('if (fatal) return',
+    'if (fatal && __pulse_fetch_failed()) { __pulse_fastly_jwt_send_error(); return; }\n    if (fatal) return');
+  const marker = 'function __pulse_fastly_jwt_send_error(): void {';
+  if (!source.includes(marker)) throw new Error('Fastly fetch error boundary drift.');
+  return source.replace(marker, marker + ' if (__pulse_fetch_send_error()) return;');
+}
+module.exports = {runtimeSource, instrument};