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

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

@@ -0,0 +1,44 @@
+'use strict';
+
+function runtimeSource() {
+  return `
+let __pulse_request_body_failure: i32 = 0
+// Validate the bounded, assembled request bytes before any text projection.
+function __pulse_request_utf8_valid(bytes: Uint8Array): bool {
+  for (let i = 0; i < bytes.length;) {
+    const lead = bytes[i++]; if (lead < 128) continue;
+    let count = 0, minimum = 128, maximum = 191;
+    if (lead >= 194 && lead <= 223) count = 1;
+    else if (lead >= 224 && lead <= 239) { count = 2; if (lead == 224) minimum = 160; if (lead == 237) maximum = 159; }
+    else if (lead >= 240 && lead <= 244) { count = 3; if (lead == 240) minimum = 144; if (lead == 244) maximum = 143; }
+    else return false;
+    if (i + count > bytes.length || i32(bytes[i]) < minimum || i32(bytes[i]) > maximum) return false;
+    i++; for (let n = 1; n < count; n++, i++) if (bytes[i] < 128 || bytes[i] > 191) return false;
+  }
+  return true;
+}
+function __pulse_request_send_body_error(): bool {
+  if (__pulse_fastly_last_error != PULSE_ERROR_REQUEST_BODY) return false;
+  const output = new __PulseFastlyValue(); output.kind = PULSE_VALUE_RESPONSE;
+  output.status = __pulse_fastly_error_stage == 21 ? 413 : 400;
+  output.text = output.status == 413 ? "Payload Too Large" : "Bad Request";
+  output.headers.push(new __PulseFastlyHeader("content-type", "text/plain; charset=utf-8"));
+  __pulse_fastly_last_error = 0; __pulse_fastly_error_stage = 0; __pulse_fastly_error_effect = -1;
+  const status = __pulse_fastly_send_result(__pulse_fastly_put(output));
+  if (status != FASTLY_STATUS_OK) __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 104, -1);
+  return true;
+}
+`;
+}
+
+function instrument(source, applicationErrors) {
+  if (!applicationErrors) source = source.replace(/function (host_\w+)\(([^)]*)\): (i32|void) \{/g,
+    (declaration, _name, _args, result) => `${declaration} if (__pulse_fastly_last_error == PULSE_ERROR_REQUEST_BODY) return${result === 'void' ? '' : ' 0'};`);
+  // The existing terminal failure path also covers applications without an
+  // error handler. Request-budget instrumentation subsequently takes priority.
+  const marker = 'function __pulse_fastly_jwt_send_error(): void {';
+  if (!source.includes(marker)) throw new Error('Fastly request-body error boundary drift.');
+  return source.replace(marker, marker + ' if (__pulse_request_send_body_error()) return;');
+}
+
+module.exports = { runtimeSource, instrument };

package/src/build/native-request-headers.js

@@ -0,0 +1,93 @@
+'use strict';
+
+// Fastly's multi-value ABI returns NUL-delimited pages and an i64 next cursor
+// (-1 marks completion). See https://docs.rs/fastly/latest/src/fastly/abi.rs.html
+// Keep this independent of outbound response headers.
+function runtimeSource() {
+  return `
+@external("fastly_http_req", "header_names_get")
+declare function __pulse_request_header_names(handle: i32, buffer: usize, size: i32, cursor: i32, end: usize, written: usize): i32
+@external("fastly_http_req", "header_values_get")
+declare function __pulse_request_header_values(handle: i32, name: usize, length: i32, buffer: usize, size: i32, cursor: i32, end: usize, written: usize): i32
+let __pulse_request_headers_snapshot: i32 = 0
+let __pulse_request_headers_failed: bool = false
+let __pulse_request_headers_bytes: i32 = 0
+function __pulse_request_headers_fail(): void {
+  __pulse_request_headers_failed = true;
+  __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 24, -1);
+}
+function __pulse_request_header_list(name: string, names: bool): Array<string> {
+  const output = new Array<string>();
+  const buffer = new Uint8Array(PULSE_FASTLY_BUFFER_BYTES);
+  const end = new StaticArray<i64>(1), written = new StaticArray<i32>(1);
+  const key = __pulse_fastly_utf8(name);
+  let cursor: i64 = 0;
+  let bytes = 0;
+  for (let page = 0; page < 256; page++) {
+    end[0] = 0; written[0] = -1;
+    const status = names
+      ? __pulse_request_header_names(__pulse_fastly_request_handle, buffer.dataStart, buffer.length, i32(cursor), changetype<usize>(end), changetype<usize>(written))
+      : __pulse_request_header_values(__pulse_fastly_request_handle, changetype<usize>(key), key.byteLength, buffer.dataStart, buffer.length, i32(cursor), changetype<usize>(end), changetype<usize>(written));
+    const count = written[0], next = end[0];
+    if (status == FASTLY_STATUS_OK && count == 0 && cursor == 0 && next == 0) return output;
+    if (status != FASTLY_STATUS_OK || count < 0 || count > buffer.length
+      || (next != -1 && (next <= cursor || next > 4294967295 || count == 0))) {
+      __pulse_request_headers_fail(); return output;
+    }
+    bytes += count;
+    if (bytes > PULSE_FASTLY_BUFFER_BYTES) { __pulse_request_headers_fail(); return output; }
+    let start = 0;
+    for (let i = 0; i < count; i++) {
+      if (buffer[i] != 0) continue;
+      const size = i - start;
+      // Count name bytes once per returned pair, including both terminators.
+      if (!names) __pulse_request_headers_bytes += key.byteLength + size + 2;
+      if (output.length >= 256 || (names && size == 0) || __pulse_request_headers_bytes > PULSE_FASTLY_BUFFER_BYTES) {
+        __pulse_request_headers_fail(); return output;
+      }
+      output.push(String.UTF8.decodeUnsafe(buffer.dataStart + start, size, false));
+      start = i + 1;
+    }
+    if (start != count) { __pulse_request_headers_fail(); return output; }
+    if (next == -1) return output;
+    cursor = next;
+  }
+  __pulse_request_headers_fail(); return output;
+}
+function __pulse_request_headers_read(): i32 {
+  if (__pulse_request_headers_failed) { __pulse_request_headers_fail(); return 0; }
+  if (__pulse_request_headers_snapshot != 0) return __pulse_request_headers_snapshot;
+  const names = __pulse_request_header_list("", true);
+  if (__pulse_request_headers_failed) return 0;
+  const output = host_value_array();
+  let pairs = 0;
+  for (let n = 0; n < names.length; n++) {
+    const name = names[n].toLowerCase();
+    for (let previous = 0; previous < n; previous++) {
+      if (names[previous].toLowerCase() == name) { __pulse_request_headers_fail(); return 0; }
+    }
+    const values = __pulse_request_header_list(name, false);
+    if (__pulse_request_headers_failed) return 0;
+    if (values.length == 0 || pairs + values.length > 256) { __pulse_request_headers_fail(); return 0; }
+    pairs += values.length;
+    for (let v = 0; v < values.length; v++) {
+      const pair = host_value_array();
+      host_value_array_push(pair, __pulse_fastly_string_value(name));
+      host_value_array_push(pair, __pulse_fastly_string_value(values[v]));
+      host_value_array_push(output, pair);
+    }
+  }
+  __pulse_fastly_deep_freeze(output);
+  __pulse_request_headers_snapshot = output;
+  return output;
+}
+`;
+}
+
+function instrument(source, applicationErrors, used) {
+  if (applicationErrors || !used) return source;
+  return source.replace(/function (host_\w+)\(([^)]*)\): (i32|void) \{/g,
+    (declaration, _name, _args, result) => `${declaration} if (__pulse_request_headers_failed) return${result === 'void' ? '' : ' 0'};`);
+}
+
+module.exports = { runtimeSource, instrument };

package/src/build/native-string-values.js

@@ -0,0 +1,113 @@
+'use strict';
+
+// Host value handles live for the invocation. Store concatenation as shared,
+// immutable prefixes instead of retaining a flat copy for every intermediate.
+// This changes representation only: coercion happens at the original operation,
+// and aliases keep their original string even after a later append.
+const nativeStringFields = `
+  textLeaf: string = ""
+  textLeft: __PulseFastlyValue | null = null
+  textRight: __PulseFastlyValue | null = null
+  textLength: i32 = 0
+  get text(): string {
+    if (this.textLeft === null) return this.textLeaf
+    const pending = new Array<__PulseFastlyValue>()
+    const parts = new Array<string>()
+    pending.push(this)
+    while (pending.length > 0) {
+      const node = pending.pop()
+      if (node.textLeft === null) parts.push(node.textLeaf)
+      else { pending.push(node.textRight!); pending.push(node.textLeft!) }
+    }
+    this.textLeaf = parts.join("")
+    this.textLeft = null
+    this.textRight = null
+    return this.textLeaf
+  }
+  set text(value: string) {
+    this.textLeaf = value
+    this.textLength = value.length
+    this.textLeft = null
+    this.textRight = null
+  }
+`;
+const nativeStringConcat = `
+function __pulse_fastly_concat(leftHandle: i32, rightHandle: i32): i32 {
+  let left = __pulse_fastly_value(leftHandle)
+  let right = __pulse_fastly_value(rightHandle)
+  // Snapshot non-string coercions now; a referenced object can change later.
+  if (left.kind != PULSE_VALUE_STRING) {
+    leftHandle = __pulse_fastly_string_value(__pulse_fastly_string(leftHandle))
+    left = __pulse_fastly_value(leftHandle)
+  }
+  if (right.kind != PULSE_VALUE_STRING) {
+    rightHandle = __pulse_fastly_string_value(__pulse_fastly_string(rightHandle))
+    right = __pulse_fastly_value(rightHandle)
+  }
+  if (left.textLength == 0) return rightHandle
+  if (right.textLength == 0) return leftHandle
+  const length = i64(left.textLength) + i64(right.textLength)
+  if (length > String.MAX_LENGTH) { __pulse_fastly_fail(PULSE_ERROR_VALUE, 57, -1); return 0 }
+  const value = new __PulseFastlyValue()
+  value.kind = PULSE_VALUE_STRING
+  value.textLength = i32(length)
+  value.textLeft = left
+  value.textRight = right
+  return __pulse_fastly_put(value)
+}
+`;
+
+// ECMAScript WhiteSpace + LineTerminator code units. Keep this explicit rather
+// than inheriting the AssemblyScript library's Unicode whitespace policy.
+const nativeStringTrim = `
+function __pulse_fastly_trim_space(code: i32): bool {
+  return (code >= 9 && code <= 13) || code == 32 || code == 160 || code == 5760
+    || (code >= 8192 && code <= 8202) || code == 8232 || code == 8233
+    || code == 8239 || code == 8287 || code == 12288 || code == 65279
+}
+function host_value_string_trim(handle: i32): i32 {
+  const value = __pulse_fastly_value(handle)
+  if (value.kind != PULSE_VALUE_STRING) { __pulse_fastly_fail(PULSE_ERROR_VALUE, 56, -1); return 0 }
+  let start = 0
+  let end = value.text.length
+  while (start < end && __pulse_fastly_trim_space(value.text.charCodeAt(start))) start += 1
+  while (end > start && __pulse_fastly_trim_space(value.text.charCodeAt(end - 1))) end -= 1
+  return __pulse_fastly_string_value(value.text.substring(start, end))
+}
+`;
+
+// Indexed reads expose one UTF-16 code unit, including an isolated surrogate.
+// Validate property spelling before converting to i32: "01", fractions,
+// negative indices and nonnumeric keys are ordinary missing properties.
+const nativeStringIndex = `
+function __pulse_fastly_string_index(value: __PulseFastlyValue, keyHandle: i32): i32 {
+  const key = __pulse_fastly_value(keyHandle)
+  if (key.kind == PULSE_VALUE_STRING && key.text == "length") return host_value_number(value.textLength)
+  if (key.kind != PULSE_VALUE_NUMBER && key.kind != PULSE_VALUE_STRING) return host_value_undefined()
+  const index = __pulse_fastly_number(keyHandle)
+  if (!(index >= 0 && index < value.textLength)) return host_value_undefined()
+  const position = i32(index)
+  if (index != f64(position)) return host_value_undefined()
+  if (key.kind == PULSE_VALUE_STRING && key.text != position.toString()) return host_value_undefined()
+  let node = value
+  let offset = position
+  while (node.textLeft !== null) {
+    const left = node.textLeft!
+    if (offset < left.textLength) node = left
+    else { offset -= left.textLength; node = node.textRight! }
+  }
+  return __pulse_fastly_string_value(node.textLeaf.charAt(offset))
+}
+`;
+
+function needsNativeValueFailureGuard(plan) {
+  if ((plan.schemas?.references || []).some(entry => ['value-encode', 'text-decode'].includes(entry.usage))) return true;
+  function containsValueOperation(node) {
+    if (!node || typeof node !== 'object') return false;
+    if (node.kind === 'pure-loop' || (node.kind === 'method-call' && node.method === 'string.trim')) return true;
+    return Object.values(node).some(containsValueOperation);
+  }
+  return containsValueOperation(plan.entry?.body) || containsValueOperation(plan.handlers) || containsValueOperation(plan.stages) || containsValueOperation(plan.helpers) || containsValueOperation(plan.effects);
+}
+
+module.exports = { nativeStringFields, nativeStringConcat, nativeStringTrim, nativeStringIndex, needsNativeValueFailureGuard };

package/src/build/native-value-budget.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const { CANONICAL_NATIVE_READ_LOOP_MEMORY: policy, hasBoundedReadLoop } = require('@pulse-compute/wasm-contracts/handler/canonical-native-runtime');
+
+function runtimeSource(limits = policy) {
+  return `
+let __pulse_memory_bytes: i64 = 0
+let __pulse_memory_values: i64 = 0
+let __pulse_memory_failed: bool = false
+function __pulse_memory_charge(values: i64, bytes: i64): void {
+  if (__pulse_memory_failed) unreachable()
+  if (values > ${limits.maxValues} - __pulse_memory_values || bytes > ${limits.maxBytes} - __pulse_memory_bytes) {
+    __pulse_memory_failed = true
+    __pulse_fastly_fail(1010, values > ${limits.maxValues} - __pulse_memory_values ? 173 : 172, -1)
+    __pulse_invocation_close()
+    unreachable()
+  }
+  __pulse_memory_values += values
+  __pulse_memory_bytes += bytes
+}
+function __pulse_memory_value_push(target: Array<i32>, value: i32): void {
+  __pulse_memory_charge(1, ${limits.edgeBytes})
+  target.push(value)
+}
+function __pulse_memory_key_push(target: Array<string>, value: string): void {
+  __pulse_memory_charge(1, ${limits.edgeBytes} + i64(value.length) * 2)
+  target.push(value)
+}
+function __pulse_memory_header_push(target: Array<__PulseFastlyHeader>, value: __PulseFastlyHeader): void {
+  __pulse_memory_charge(1, ${limits.valueBytes} + i64(value.name.length + value.value.length) * 2)
+  target.push(value)
+}
+export function pulse_fastly_memory_bytes(): i64 { return __pulse_memory_bytes }
+export function pulse_fastly_memory_values(): i64 { return __pulse_memory_values }
+`;
+}
+
+function instrument(source, plan) {
+  if (!hasBoundedReadLoop(plan)) return source;
+  function insert(needle, extra) {
+    if (source.split(needle).length !== 2) throw new Error('Native value budget instrumentation mismatch: ' + needle);
+    source = source.replace(needle, needle + extra);
+  }
+  // Text assignments include lazy fetch bodies and response bodies as well as
+  // strings. Ropes reserve their eventual flat size before materialization.
+  insert('\n  set text(value: string) {', '\n    __pulse_memory_charge(0, i64(value.length) * 2)');
+  insert('\nfunction __pulse_fastly_put(value: __PulseFastlyValue): i32 {',
+    ` __pulse_memory_charge(1, ${policy.valueBytes} + (value.textLeft === null ? 0 : i64(value.textLength) * 2));`);
+  const helpers = { keys: 'key', values: 'value', headers: 'header' };
+  // Skip quoted data and comments: authored text can contain source-like text.
+  const tokens = /("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\/\/[^\n]*|\/\*[\s\S]*?\*\/)|\b([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\.(keys|values|headers)\.push\(/g;
+  source = source.replace(tokens, (match, quoted, object, field) => quoted || `__pulse_memory_${helpers[field]}_push(${object}.${field}, `);
+  const code = source.replace(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\/\/[^\n]*|\/\*[\s\S]*?\*\//g, '');
+  if (/\.(keys|values|headers)\.push\(/.test(code)) throw new Error('Unmetered Native container growth.');
+  return source + runtimeSource();
+}
+
+module.exports = { policy, hasBoundedReadLoop, runtimeSource, instrument };

package/src/build/package-native-application.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const {
+  CANONICAL_NATIVE_IMPORT_NAMES,
+  CANONICAL_NATIVE_VALUE_TRANSFER_MAX_BYTES
+} = require('@pulse-compute/wasm-contracts/handler/canonical-native-runtime');
+
+function enabled(plan) { return Boolean(plan.packages && plan.packages.application); }
+
+// The package owns request dispatch, codecs and continuations. This adapter only
+// binds its canonical host imports to the same Fastly runtime as ordinary handlers.
+function portable(plan) {
+  const application = plan.packages.application;
+  if (application.contractId !== 'pulse.entities'
+    || application.version !== 'pulse.package-native-application.v1'
+    || application.effectFailure !== 'package-completion'
+    || application.automaticFallback !== false
+    || crypto.createHash('sha256').update(application.source).digest('hex') !== application.sourceHash) {
+    throw new Error('Unsupported or invalid Fastly package Native application.');
+  }
+  const source = application.source.replace(
+    /^@external\("pulse_host", "([a-z_]+)"\) declare function (\w+)\(([^)]*)\): (i32|void)$/gm,
+    (_declaration, name, symbol, parameters, result) => {
+      if (!CANONICAL_NATIVE_IMPORT_NAMES.includes(name)) throw new Error('Unsupported package host import: ' + name);
+      const args = parameters ? parameters.split(',').map(parameter => parameter.trim().split(':')[0]).join(', ') : '';
+      if (name === 'value_json') return `function ${symbol}(${parameters}): i32 {
+  // A failed request read must reach the provider's terminal error response,
+  // without trapping JSON.parse<string> in the guest first.
+  if (handle <= 0) return changetype<i32>('""')
+  const text = __pulse_fastly_json(handle, 0)
+  if (String.UTF8.byteLength(text) > ${CANONICAL_NATIVE_VALUE_TRANSFER_MAX_BYTES}) {
+    __pulse_fastly_fail(PULSE_ERROR_VALUE, 172, -1); return changetype<i32>('null')
+  }
+  return changetype<i32>(text)
+}`;
+      const guard = name === 'log' ? `if (level <= 0 || level > ${Number(plan.logging.reporting.level)}) return; ` : '';
+      return `function ${symbol}(${parameters}): ${result} { ${guard}${result === 'void' ? '' : 'return '}host_${name}(${args}) }`;
+    }
+  );
+  if (source.includes('@external("pulse_host",')) throw new Error('Unbound package Native host import.');
+  const codecs = (plan.schemas?.registry?.schemas || []).map((_schema, index) => `
+function __pulse_schema_decode_${index}(input: string): string { return changetype<string>(pulse_schema_decode(${index}, changetype<i32>(input))) }
+function __pulse_schema_encode_${index}(input: string): string { return changetype<string>(pulse_schema_encode(${index}, changetype<i32>(input))) }`).join('\n');
+  return { ...application, source: source + codecs + `\nconst __pulse_application_plan_hash: string = ${JSON.stringify(plan.planHash)}\n` };
+}
+
+function runtimeSource() {
+  return `
+const __pulse_package_failed = new StaticArray<i32>(PULSE_FASTLY_EFFECT_COUNT)
+function __pulse_package_take_effect_failure(): bool {
+  const code = __pulse_fastly_last_error
+  // Deadlines, invalid lifecycle transitions and request/body failures remain
+  // provider-terminal. Only an admitted effect's operational failure is framed.
+  if (__pulse_fastly_error_stage == 260 || __pulse_fastly_error_stage == 261) return false
+  if (code != PULSE_ERROR_HOSTCALL && code != PULSE_ERROR_TRANSPORT
+    && code != PULSE_ERROR_JSON && code != PULSE_ERROR_SCHEMA && code != PULSE_ERROR_VALUE) return false
+  __pulse_fastly_last_error = 0; __pulse_fastly_error_stage = 0; __pulse_fastly_error_effect = -1
+  return true
+}
+function host_effect_begin(effectIndex: i32, payload: i32): void {
+  if (__pulse_fastly_last_error != 0) return
+  __pulse_package_effect_begin(effectIndex, payload)
+  if (__pulse_package_take_effect_failure()) unchecked(__pulse_package_failed[effectIndex] = 1)
+}
+`;
+}
+
+function instrument(source) {
+  const signature = 'function host_effect_begin(effectIndex: i32, payload: i32): void {';
+  if (!source.includes(signature)) throw new Error('Fastly package effect admission boundary drift.');
+  return source.replace(signature, 'function __pulse_package_effect_begin(effectIndex: i32, payload: i32): void {') + runtimeSource();
+}
+
+function driverLoop() {
+  return `  while (runStatus == 1 && __pulse_fastly_last_error == 0) {
+    for (let effectIndex = 0; effectIndex < PULSE_FASTLY_EFFECT_COUNT; effectIndex += 1) {
+      const invocation = unchecked(__pulse_invocation_tickets[effectIndex])
+      if (invocation == 0) continue
+      let failed = unchecked(__pulse_package_failed[effectIndex]) != 0
+      unchecked(__pulse_package_failed[effectIndex] = 0)
+      let result = failed ? 0 : __pulse_fastly_resolve_effect(effectIndex)
+      if (__pulse_package_take_effect_failure()) { failed = true; result = 0 }
+      if (__pulse_fastly_last_error != 0) { __pulse_fastly_jwt_send_error(); return }
+      if (!failed && result <= 0) { __pulse_fastly_fail(PULSE_ERROR_STATE, 101, effectIndex); __pulse_fastly_jwt_send_error(); return }
+      if (__pulse_invocation_settle(effectIndex, invocation, result) != 1 || __pulse_fastly_last_error != 0) {
+        __pulse_fastly_fail(PULSE_ERROR_STATE, 101, effectIndex); __pulse_fastly_jwt_send_error(); return
+      }
+    }
+    runStatus = pulse_resume()
+  }`;
+}
+
+module.exports = { enabled, portable, instrument, driverLoop };

package/src/build/request-budget.as.ts

@@ -0,0 +1,49 @@
+// Provider-owned request lifecycle. No wall time or caller header grants time.
+@external('fastly_async_io', 'select') declare function __request_select(handles: usize, count: i32, timeout: i32, done: usize): i32
+let __request_deadline: i64 = -1;
+let __request_last_clock: i64 = -1;
+let __request_expired: bool = false;
+let __request_error_response: bool = false;
+export function pulse_fastly_request_expired(): i32 { return __request_expired ? 1 : 0; }
+function __request_clock(): i64 {
+  const out = new StaticArray<i64>(1);
+  if (wasi_snapshot_preview1_clock_time_get(1, 1, changetype<usize>(out)) != 0 || out[0] < __request_last_clock) {
+    __request_expired = true;
+    return -1;
+  }
+  __request_last_clock = out[0];
+  return out[0];
+}
+function __request_remaining(): i32 {
+  if (__request_expired) return 0;
+  const now = __request_clock();
+  if (now < 0 || now >= __request_deadline) { __request_expired = true; return 0; }
+  return i32((__request_deadline - now + 999999) / 1000000);
+}
+function __request_check(index: i32 = -1): bool {
+  if (__request_error_response) return true;
+  if (__request_remaining() > 0) return true;
+  __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 260, index);
+  return false;
+}
+function __request_wait(handle: i32, index: i32): bool {
+  const remaining = __request_remaining();
+  if (remaining <= 0) return __request_check(index);
+  const handles = new StaticArray<i32>(1), ready = new StaticArray<i32>(1);
+  handles[0] = handle;
+  const status = __request_select(changetype<usize>(handles), 1, remaining, changetype<usize>(ready));
+  if (status != 0) { __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 261, index); return false; }
+  if (ready[0] == -1) __request_expired = true;
+  return __request_check(index);
+}
+function __request_send_timeout(): void {
+  // A timeout says nothing about remote acceptance of dispatched writes.
+  __request_error_response = true;
+  __pulse_fastly_last_error = 0;
+  const options = host_value_object();
+  host_value_object_set(options, __pulse_fastly_string_value('status'), host_value_number(504.0));
+  const response = host_response_text(__pulse_fastly_string_value('Gateway Timeout'), options);
+  __pulse_fastly_last_error = 0;
+  const status = __pulse_fastly_send_result(response);
+  if (status != 0) __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 262, -1);
+}

package/src/build/request-budget.js

@@ -0,0 +1,45 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const {normalizeRequestDuration} = require('@pulse-compute/runtime/host');
+
+function instrumentRequestBudget(input, duration, plan) {
+  const ms = normalizeRequestDuration(duration);
+  if (ms === undefined) return input;
+  let source = input;
+  const replace = (before, after) => {
+    if (!source.includes(before)) throw new Error('Fastly request budget boundary drift: ' + before.slice(0, 100));
+    source = source.replace(before, after);
+  };
+  replace('  __pulse_fastly_last_error = fastly_abi_init', `  __request_expired = false; __request_error_response = false; __request_last_clock = -1;
+  __request_deadline = __request_clock() + i64(${ms}) * 1000000;
+  __pulse_fastly_last_error = fastly_abi_init`);
+  replace('  const handles = new StaticArray<i32>(2)\n  const downstreamStatus', `  if (!__request_check()) { __request_send_timeout(); return; }
+  const handles = new StaticArray<i32>(2)
+  const downstreamStatus`);
+  replace('function host_effect_begin(effectIndex: i32, payload: i32): void {', 'function host_effect_begin(effectIndex: i32, payload: i32): void {\n  if (!__request_check(effectIndex)) return;');
+  replace('function __pulse_invocation_settle(index: i32, ticket: i32, result: i32): i32 {', 'function __pulse_invocation_settle(index: i32, ticket: i32, result: i32): i32 {\n  if (!__request_check(index)) return 0;');
+  replace('  let runStatus = pulse_start()', '  if (!__request_check()) { __request_send_timeout(); return; }\n  let runStatus = pulse_start()');
+  replace('function __pulse_fastly_resolve_effect(effectIndex: i32): i32 {', `function __pulse_fastly_resolve_effect(effectIndex: i32): i32 {
+  if (!__request_check(effectIndex)) return 0;
+  const kind = __pulse_fastly_effect_kind(effectIndex);
+  if (unchecked(__pulse_fastly_pending_mode[effectIndex]) == PULSE_FASTLY_PENDING_ASYNC && kind != 12 && kind != 13 && kind != 14 && kind != 21 && ${plan.effects.filter(e=>e.kind.startsWith('kv.')&&['kv.getVersioned','kv.insertIfAbsent','kv.compareAndSwap'].includes(e.kind)).map(e=>'effectIndex != '+plan.effects.indexOf(e)).join(' && ')||'true'}) {
+    if (!__request_wait(unchecked(__pulse_fastly_pending[effectIndex]), effectIndex)) return 0;
+  }`);
+  replace('    const buffer = new Uint8Array(PULSE_FASTLY_BUFFER_BYTES), read = __pulse_fastly_out_i32();', '    if (!__request_wait(handle, effectIndex)) return "";\n    const buffer = new Uint8Array(PULSE_FASTLY_BUFFER_BYTES), read = __pulse_fastly_out_i32();');
+  replace('while (offset < bytes.byteLength) { const written', 'while (offset < bytes.byteLength) { if (!__request_check()) return 1; const written');
+  replace('function __pulse_fastly_send_result(handle: i32): i32 {', 'function __pulse_fastly_send_result(handle: i32): i32 { if (!__request_check()) return 1;');
+  replace('return fastly_http_resp_send_downstream(responseHandle, bodyHandle, 0)', 'if (!__request_check()) return 1; return fastly_http_resp_send_downstream(responseHandle, bodyHandle, 0)');
+  replace('if (sendStatus != FASTLY_STATUS_OK) __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 104, -1)', 'if (sendStatus != FASTLY_STATUS_OK) { if (__request_expired) { __request_send_timeout(); return; } __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 104, -1); }');
+  replace('status = fastly_http_req_send_async(requestHandle', 'if (!__request_check(effectIndex)) return; status = fastly_http_req_send_async(requestHandle');
+  replace('function __pulse_fastly_ready_effect(effectIndex: i32, handle: i32): void {', 'function __pulse_fastly_ready_effect(effectIndex: i32, handle: i32): void { if (!__request_check(effectIndex)) return;');
+  source = source.replace('if (fatal) return', 'if (fatal) { if (__request_expired || !__request_check()) __request_send_timeout(); return; }');
+  replace('function __pulse_fastly_jwt_send_error(): void {', 'function __pulse_fastly_jwt_send_error(): void { if (__request_expired || !__request_check()) { __request_send_timeout(); return; }');
+  source = source.replaceAll('runStatus = pulse_resume()', 'if (!__request_check()) { __request_send_timeout(); return; }\n    runStatus = pulse_resume()');
+  replace('  const result = pulse_result_handle()', '  if (!__request_check()) { __request_send_timeout(); return; }\n  const result = pulse_result_handle()');
+  if (source.includes('__kv_deadline[index] = start +')) replace('__kv_deadline[index] = start + i64(__KV_timeoutMs) * 1000000;', '__kv_deadline[index] = min<i64>(__request_deadline, start + i64(__KV_timeoutMs) * 1000000);');
+  if (source.includes('__s3_deadlines[index] = start +')) replace('__s3_deadlines[index] = start + i64(binding.timeout) * 1000000;', '__s3_deadlines[index] = min<i64>(__request_deadline, start + i64(binding.timeout) * 1000000);');
+  if (source.includes('function __pulse_fastly_write_binary(')) replace('const written = new StaticArray<i32>(1); let offset = 0;\n  while (offset < data.length) {', 'const written = new StaticArray<i32>(1); let offset = 0;\n  while (offset < data.length) { if (!__request_check()) return 1;');
+  return source + '\n' + fs.readFileSync(path.join(__dirname,'request-budget.as.ts'),'utf8');
+}
+module.exports = {instrumentRequestBudget};

package/src/build/s3-body.as.ts

@@ -0,0 +1,97 @@
+// Fastly owns opaque body handles. No bytes enter an application value or text codec.
+@lazy const __s3_bodies = new Array<__PulseFastlyValue>()
+function __s3_body_failure(reason: string): i32 {
+  const output = new __PulseFastlyValue(); output.kind = PULSE_VALUE_RESPONSE;
+  output.status = reason == 'timeout' ? 504 : 502;
+  output.headers.push(new __PulseFastlyHeader('x-pulse-s3-error', reason));
+  return __pulse_fastly_put(output);
+}
+function __s3_close_bodies(): void {
+  for (let i = 0; i < __s3_bodies.length; i++) {
+    const value = __s3_bodies[i];
+    if (value.s3Body) { __s3_close_body(value.bodyHandle); value.s3Body = false; }
+  }
+  __s3_bodies.length = 0;
+}
+function __s3_body_response(index: i32, response: i32, body: i32, status: i32): i32 {
+  const output = new __PulseFastlyValue(); output.kind = PULSE_VALUE_RESPONSE; output.status = status;
+  const buffer = new Uint8Array(16384), end = new StaticArray<i64>(1), size = new StaticArray<i32>(1);
+  if (__s3_header_names(response, buffer.dataStart, buffer.length, 0, changetype<usize>(end), changetype<usize>(size)) != 0 || end[0] >= 0) return __s3_body_failure('protocol');
+  const names = __s3_list(buffer, size[0]); if (names === null) return __s3_body_failure('protocol');
+  let total = 0, length: f64 = -1, contentRange = ''; const seen = new Set<string>();
+  for (let i = 0; i < names.length; i++) {
+    const name = names[i].toLowerCase(), bytes = __pulse_s3_bytes(names[i]);
+    if (__s3_header_values(response, bytes.dataStart, bytes.length, buffer.dataStart, buffer.length, 0, changetype<usize>(end), changetype<usize>(size)) != 0 || end[0] >= 0) return __s3_body_failure('protocol');
+    const values = __s3_list(buffer, size[0]); if (values === null) return __s3_body_failure('protocol');
+    const selected = name == 'content-length' || name == 'content-type' || name == 'etag' || name == 'content-encoding' || name == 'content-range';
+    if (selected && (seen.has(name) || values.length != 1)) return __s3_body_failure('protocol');
+    seen.add(name);
+    for (let v = 0; v < values.length; v++) {
+      const value = values[v], count = __pulse_s3_bytes(value).length;
+      total += bytes.length + count + 4; if (total > 16384) return __s3_body_failure('protocol');
+      if (!selected) continue;
+      if (count > 1024 || !__pulse_s3_scalar(value, true)) return __s3_body_failure('protocol');
+      if (name == 'content-encoding') { if (value.toLowerCase() != 'identity') return __s3_body_failure('protocol'); continue; }
+      if (name == 'content-length') {
+        length = __pulse_s3_decimal(value); if (length < 0) return __s3_body_failure('protocol');
+        if (status != 200 && status != 206) continue;
+      }
+      if (name == 'etag' && !value.length) return __s3_body_failure('protocol');
+      if (name == 'content-range') { if (!value.length || count > 128) return __s3_body_failure('protocol'); contentRange = value; }
+      output.headers.push(new __PulseFastlyHeader(name, value));
+    }
+  }
+  const binding = __pulse_fastly_s3_binding(index);
+  if ((status == 200 || status == 206) && length < 0) return __s3_body_failure('protocol');
+  if (!__pulse_s3_body_range(status, length, contentRange, binding.range, binding.ifNoneMatch.length > 0)) return __s3_body_failure('protocol');
+  if (__s3_remaining(index) == 0) return __s3_body_failure('timeout');
+  if (binding.method != 'HEAD' && (status == 200 || status == 206)) {
+    if (length > binding.max) return __s3_body_failure('too-large');
+    output.s3Body = true; output.bodyHandle = body; output.s3Length = i32(length); output.s3Deadline = __s3_deadlines[index];
+    __s3_bodies.push(output);
+  }
+  return __pulse_fastly_put(output);
+}
+function __s3_body_remaining(value: __PulseFastlyValue): i32 {
+  const now = __s3_clock(1), ns = value.s3Deadline - now;
+  return now < 0 || ns <= 0 ? 0 : i32((ns + 999999) / 1000000);
+}
+function __s3_body_wait(value: __PulseFastlyValue, handle: i32): bool {
+  const timeout = __s3_body_remaining(value); if (!timeout) return false;
+  const handles = new StaticArray<i32>(1), done = new StaticArray<i32>(1); handles[0] = handle;
+  return __s3_select(changetype<usize>(handles), 1, timeout, changetype<usize>(done)) == 0 && done[0] != -1 && __s3_body_remaining(value) > 0;
+}
+function __s3_copy_body(value: __PulseFastlyValue, output: i32): bool {
+  const buffer = new Uint8Array(16384), size = new StaticArray<i32>(1), written = new StaticArray<i32>(1);
+  let count = 0;
+  while (true) {
+    if (!__s3_body_wait(value, value.bodyHandle)) return false;
+    if (fastly_http_body_read(value.bodyHandle, buffer.dataStart, buffer.length, changetype<usize>(size)) != 0 || size[0] < 0 || size[0] > buffer.length) return false;
+    if (__s3_body_remaining(value) == 0) return false;
+    if (!size[0]) return count == value.s3Length;
+    count += size[0]; if (count > value.s3Length) return false;
+    let offset = 0;
+    while (offset < size[0]) {
+      if (!__s3_body_wait(value, output)) return false;
+      if (fastly_http_body_write(output, buffer.dataStart + offset, size[0] - offset, 0, changetype<usize>(written)) != 0 || written[0] <= 0 || written[0] > size[0] - offset) return false;
+      offset += written[0];
+    }
+  }
+}
+function __s3_send_body(value: __PulseFastlyValue): i32 {
+  if (!__s3_body_remaining(value)) return __pulse_fastly_send_result(__s3_body_failure('timeout'));
+  const response = new StaticArray<i32>(1), body = new StaticArray<i32>(1);
+  if (fastly_http_resp_new(changetype<usize>(response)) != 0) return 1;
+  if (fastly_http_body_new(changetype<usize>(body)) != 0) { __s3_close_resp(response[0]); return 1; }
+  let ok = fastly_http_resp_status_set(response[0], value.status) == 0;
+  for (let i = 0; ok && i < value.headers.length; i++) {
+    const header = value.headers[i], name = __pulse_s3_bytes(header.name), data = __pulse_s3_bytes(header.value);
+    ok = fastly_http_resp_header_append(response[0], name.dataStart, name.length, data.dataStart, data.length) == 0;
+  }
+  if (!ok || fastly_http_resp_send_downstream(response[0], body[0], 1) != 0) { __s3_close_resp(response[0]); __s3_close_body(body[0]); return 1; }
+  ok = __s3_copy_body(value, body[0]);
+  __s3_close_body(value.bodyHandle); value.s3Body = false;
+  // close is successful EOF for a streaming handle. On failure leave it unfinished:
+  // Compute aborts the downstream stream when this invocation exits (SDK semantics).
+  return ok ? __s3_close_body(body[0]) : 1;
+}