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

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

@@ -107,7 +107,7 @@ function needsNativeValueFailureGuard(plan) {
     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.effects);
+  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.js

@@ -18,11 +18,12 @@ function instrumentRequestBudget(input, duration, plan) {
   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 && ${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 (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();');
@@ -38,6 +39,7 @@ function instrumentRequestBudget(input, duration, plan) {
   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;
+}

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

@@ -10,6 +10,7 @@
 @external('fastly_http_resp', 'header_values_get') declare function __s3_header_values(response: i32, name: usize, length: i32, buffer: usize, size: i32, cursor: i32, end: usize, written: usize): i32
 
 class __PulseS3Binding {
+  method: string = ''; range: string = ''; ifNoneMatch: string = '';
   contentType: string = ''; endpoint: string = ''; bucket: string = ''; region: string = ''; backend: string = '';
   id: string = ''; secret: string = ''; token: string = ''; max: i32 = 32768; timeout: i32 = 10000;
 }
@@ -35,6 +36,7 @@ function __s3_result(status: string, reason: string = '', http: i32 = 0): i32 {
   return result;
 }
 function __s3_failure(index: i32, reason: string, http: i32 = 0): i32 {
+  if (__pulse_fastly_effect_kind(index) == 21) return __s3_body_failure(reason);
   return __s3_result(__pulse_fastly_effect_kind(index) == 14 ? (__s3_dispatched[index] ? 'unknown' : 'not-stored') : 'failed', reason, http);
 }
 function __s3_fail(index: i32, reason: string): void { __pulse_fastly_ready_effect(index, __s3_failure(index, reason)) }
@@ -84,10 +86,10 @@ function __pulse_fastly_s3_begin(index: i32, outer: __PulseFastlyValue): void {
   const token = binding.token.length ? __s3_secret(store[0], binding.token) : '';
   if (__s3_remaining(index) == 0) { __s3_fail(index, 'timeout'); return; }
   if (id === null || secret === null || token === null || !__pulse_s3_credentials(id, secret, token)) { __s3_fail(index, 'credentials'); return; }
-  const method = put ? 'PUT' : __pulse_fastly_effect_kind(index) == 12 ? 'HEAD' : 'GET', path = '/' + binding.bucket + '/' + encoded;
+  const method = binding.method.length ? binding.method : put ? 'PUT' : __pulse_fastly_effect_kind(index) == 12 ? 'HEAD' : 'GET', path = '/' + binding.bucket + '/' + encoded;
   const now = __s3_clock(0);
   if (now < 0 || !__pulse_s3_date(now / 1000000000).length) { __s3_fail(index, 'configuration'); return; }
-  const signature = __pulse_s3_sign(method, path, binding.endpoint.slice(8), binding.region, id, secret, token, now / 1000000000, data, binding.contentType);
+  const signature = __pulse_s3_sign(method, path, binding.endpoint.slice(8), binding.region, id, secret, token, now / 1000000000, data, binding.contentType, binding.range, binding.ifNoneMatch);
   __s3_sent_bytes[index] = data.length; __s3_digests[index] = signature.digest;
   __pulse_fastly_remember_secret(signature.digest);
   __pulse_fastly_remember_secret(signature.authorization); __pulse_fastly_remember_secret(binding.endpoint + path);
@@ -100,6 +102,8 @@ function __pulse_fastly_s3_begin(index: i32, outer: __PulseFastlyValue): void {
     && __s3_header(req, 'host', binding.endpoint.slice(8)) && __s3_header(req, 'x-amz-date', signature.date)
     && __s3_header(req, 'x-amz-content-sha256', signature.digest) && __s3_header(req, 'authorization', signature.authorization)
     && __s3_header(req, 'accept-encoding', 'identity');
+  if (ok && binding.range.length) ok = __s3_header(req, 'range', binding.range);
+  if (ok && binding.ifNoneMatch.length) ok = __s3_header(req, 'if-none-match', binding.ifNoneMatch);
   if (ok && put) ok = __s3_header(req, 'content-type', binding.contentType) && __s3_header(req, 'content-length', data.length.toString());
   if (ok && token.length) ok = __s3_header(req, 'x-amz-security-token', token);
   if (!ok || fastly_http_body_new(changetype<usize>(body)) != 0) { __s3_close_req(req); __s3_fail(index, 'transport'); return; }
@@ -135,6 +139,7 @@ function __s3_list(buffer: Uint8Array, size: i32): Array<string> | null {
   return result;
 }
 function __s3_read_response(index: i32, response: i32, body: i32, status: i32): i32 {
+  if (__pulse_fastly_effect_kind(index) == 21) return __s3_body_response(index, response, body, status);
   const put = __pulse_fastly_effect_kind(index) == 14;
   const rejected = put && status >= 400 && status <= 499 && status != 408;
   if (!put && status == 404) return __s3_result('not-found');
@@ -213,5 +218,6 @@ function __pulse_fastly_s3_wait(index: i32): i32 {
   let result: i32;
   if (fastly_http_resp_status_get(response[0], changetype<usize>(code)) != 0) result = __s3_failure(index, 'protocol');
   else result = __s3_remaining(index) == 0 ? __s3_failure(index, 'timeout', code[0]) : __s3_read_response(index, response[0], body[0], code[0]);
-  __s3_close_body(body[0]); __s3_close_resp(response[0]); return result;
+  if (!__pulse_fastly_value(result).s3Body) __s3_close_body(body[0]);
+  __s3_close_resp(response[0]); return result;
 }

package/src/build/s3-native.js

@@ -21,10 +21,10 @@ function s3NativeSource(plan, bindings) {
   const lines = ['function __pulse_fastly_s3_binding(index: i32): __PulseS3Binding {', 'const value = new __PulseS3Binding();', 'switch (index) {'];
   for (const binding of bindings.s3) {
     lines.push(`case ${binding.index}:`);
-    for (const [field, input] of Object.entries({ contentType: 'contentType', endpoint: 'endpoint', bucket: 'bucket', region: 'region', backend: 'backend', id: 'accessKeyIdSecret', secret: 'secretAccessKeySecret', token: 'sessionTokenSecret' })) lines.push(`value.${field} = ${JSON.stringify(binding[input] || '')};`);
+    for (const [field, input] of Object.entries({ method: 'method', range: 'range', ifNoneMatch: 'ifNoneMatch', contentType: 'contentType', endpoint: 'endpoint', bucket: 'bucket', region: 'region', backend: 'backend', id: 'accessKeyIdSecret', secret: 'secretAccessKeySecret', token: 'sessionTokenSecret' })) lines.push(`value.${field} = ${JSON.stringify(binding[input] || '')};`);
     lines.push(`value.max = ${binding.maxTextBytes}; value.timeout = ${binding.timeoutMs}; break;`);
   }
   lines.push('default: unreachable();', '}', 'return value;', '}');
-  return [contribution.source, fs.readFileSync(path.join(__dirname, 's3-native.as.ts'), 'utf8'), lines.join('\n')].join('\n');
+  return [contribution.source, fs.readFileSync(path.join(__dirname, 's3-native.as.ts'), 'utf8'), fs.readFileSync(path.join(__dirname, 's3-body.as.ts'), 'utf8'), lines.join('\n')].join('\n');
 }
 module.exports = { S3_IMPORTS, s3NativeSource };

package/src/build/schema-admission.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const { schemaAdmission } = require('@pulse-compute/wasm-runtime-core-as/compiler');
+
+function fastlyJsonValueAdmissionSource() {
+  return `
+class __PulseFastlyAdmissionFrame {
+  index: i32 = 0
+  constructor(public handle: i32) {}
+}
+function __pulse_fastly_admission_enter(handle: i32, budget: __PulseJsonAdmissionBudget,
+  stack: Array<__PulseFastlyAdmissionFrame>, active: Set<i32>): bool {
+  if (handle <= 0 || handle > __pulse_fastly_values.length) return budget.fail(12)
+  const value = __pulse_fastly_values[handle - 1]
+  const array = value.kind == PULSE_VALUE_ARRAY
+  const object = value.kind == PULSE_VALUE_OBJECT
+  if (!budget.node(stack.length + (array || object ? 1 : 0))) return false
+  if (value.kind == PULSE_VALUE_NULL) return budget.addBytes(4)
+  if (value.kind == PULSE_VALUE_BOOLEAN) return budget.addBytes(value.boolean != 0 ? 4 : 5)
+  if (value.kind == PULSE_VALUE_NUMBER) return isFinite(value.number) ? budget.addBytes(24) : budget.fail(11)
+  if (value.kind == PULSE_VALUE_STRING) return budget.stringBytes(value.text, false)
+  if (!array && !object) return budget.fail(12)
+  if (active.has(handle)) return budget.fail(13)
+  if (array && value.values.length > budget.limits.maxArrayItems) return budget.fail(6)
+  if (object && value.keys.length > budget.limits.maxObjectMembers) return budget.fail(5)
+  if (object && value.keys.length != value.values.length) return budget.fail(12)
+  if (!budget.addBytes(2)) return false
+  active.add(handle)
+  stack.push(new __PulseFastlyAdmissionFrame(handle))
+  return true
+}
+function __pulse_fastly_admit_bounded_value(handle: i32, limits: __PulseJsonAdmissionLimits): __PulseJsonAdmissionBudget {
+  const budget = new __PulseJsonAdmissionBudget(limits)
+  const stack = new Array<__PulseFastlyAdmissionFrame>()
+  const active = new Set<i32>()
+  if (!__pulse_fastly_admission_enter(handle, budget, stack, active)) return budget
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1]
+    const value = __pulse_fastly_values[frame.handle - 1]
+    if (frame.index == value.values.length) { active.delete(frame.handle); stack.pop(); continue }
+    const index = frame.index++
+    if (index > 0 && !budget.addBytes(1)) return budget
+    if (value.kind == PULSE_VALUE_OBJECT) {
+      if (!budget.stringBytes(value.keys[index], true) || !budget.addBytes(1)) return budget
+    }
+    if (!__pulse_fastly_admission_enter(value.values[index], budget, stack, active)) return budget
+  }
+  return budget
+}
+`;
+}
+
+// Standalone composition used by focused admission fixtures.
+function generateFastlyJsonAdmission(limits, parserMaxDepth = 64) {
+  const generated = schemaAdmission.generateJsonAdmission(limits);
+  if (!Number.isInteger(parserMaxDepth) || parserMaxDepth < 1 || parserMaxDepth > 0x7fffffff
+    || generated.identity.limits.maxDepth > parserMaxDepth) {
+    throw new TypeError('JSON admission depth exceeds the selected Fastly parser capacity.');
+  }
+  return Object.freeze({ identity: generated.identity, source: `${generated.source}
+${fastlyJsonValueAdmissionSource()}
+function __pulse_fastly_admit_value(handle: i32): __PulseJsonAdmissionBudget {
+  return __pulse_fastly_admit_bounded_value(handle, __pulse_json_limits())
+}
+function __pulse_fastly_admitted_json(text: string, duplicateMode: i32 = 0): i32 {
+  const admission = __pulse_json_admit(text, duplicateMode)
+  if (admission.failure != 0) { __pulse_fastly_fail(PULSE_ERROR_SCHEMA, 57, -1); return 0 }
+  return __pulse_fastly_parse_json(text)
+}
+function __pulse_fastly_admitted_json_text(handle: i32): string {
+  const admission = __pulse_fastly_admit_value(handle)
+  if (admission.failure != 0) { __pulse_fastly_fail(PULSE_ERROR_SCHEMA, 57, -1); return '' }
+  const text = __pulse_fastly_json(handle, 0)
+  if (String.UTF8.byteLength(text) > admission.limits.maxTextBytes) {
+    __pulse_fastly_fail(PULSE_ERROR_SCHEMA, 57, -1)
+    return ''
+  }
+  return text
+}
+` });
+}
+
+module.exports = { generateFastlyJsonAdmission, fastlyJsonValueAdmissionSource };

package/src/build/schema-nested-json.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const { schemaHasNestedJson, schemaHasScalarRecord } = require('@pulse-compute/wasm-contracts/schema-json/registry');
+const { fastlyJsonValueAdmissionSource } = require('./schema-admission.js');
+
+function hasJsonAdmission(plan) { return (plan.schemas?.registry?.schemas || []).some(schema => schema.jsonLimits); }
+function tracksJsonDuplicates(plan) {
+  return (plan.schemas?.registry?.schemas || []).some(schema => schemaHasNestedJson(schema.root) || schemaHasScalarRecord(schema.root));
+}
+function schemaParserDepth(plan, baseline = 64) {
+  return Math.max(baseline, ...(plan.schemas?.registry?.schemas || []).map(schema => schema.jsonLimits?.maxDepth || 0));
+}
+
+function nestedJsonProjectionLines(node) {
+  return [
+    ...(node.kind === 'json-object' ? ['  if (input.kind != PULSE_VALUE_OBJECT) { __pulse_fastly_fail(PULSE_ERROR_SCHEMA, 52, -1); return 0 }'] : []),
+    '  return __pulse_fastly_copy_json(valueHandle, checkDuplicates)'
+  ];
+}
+
+function schemaFetchJsonSource() {
+  return `
+function __pulse_fastly_fetch_json_headers(input: __PulseFastlyValue): __PulseFastlyValue {
+  for (let index = 0; index < input.keys.length; index++) if (input.keys[index].toLowerCase() == "content-type") return input
+  const output = new __PulseFastlyValue()
+  output.kind = PULSE_VALUE_OBJECT
+  for (let index = 0; index < input.keys.length; index++) {
+    output.keys.push(input.keys[index]); output.values.push(input.values[index])
+  }
+  output.keys.push("content-type")
+  output.values.push(__pulse_fastly_string_value("application/json; charset=utf-8"))
+  return output
+}
+function __pulse_fastly_fetch_json_body(init: __PulseFastlyValue, valueHandle: i32): string {
+  const index = __pulse_fastly_find(init, "schema")
+  let value = valueHandle
+  if (index >= 0) {
+    const schema = __pulse_fastly_value(init.values[index])
+    if (schema.kind != PULSE_VALUE_STRING || schema.text.length == 0) { __pulse_fastly_fail(PULSE_ERROR_SCHEMA, 55, -1); return '' }
+    value = __pulse_fastly_schema_apply(schema.text, valueHandle, true)
+    if (value <= 0 || __pulse_fastly_last_error != 0) return ''
+  }
+  return __pulse_fastly_json(value, 0)
+}
+`;
+}
+
+function schemaJsonAdmissionSource(plan) {
+  const schemas = plan.schemas?.registry?.schemas || [];
+  if (!hasJsonAdmission(plan)) return '';
+  const nested = schemas.some(schema => schemaHasNestedJson(schema.root));
+  return `${fastlyJsonValueAdmissionSource()}
+function __pulse_fastly_schema_parse_json(text: string, schemaHandle: i32): i32 {
+  const schema = __pulse_fastly_value(schemaHandle)
+  if (schema.kind == PULSE_VALUE_STRING) {
+${schemas.map((schema, index) => schema.jsonLimits ? `    if (schema.text == ${JSON.stringify(schema.id)} && __pulse_schema_json_scan_${index}(text, 0).failure != 0) {
+      __pulse_fastly_fail(PULSE_ERROR_SCHEMA, 57, -1); return 0
+    }` : '').join('\n')}
+  }
+  return __pulse_fastly_parse_json(text)
+}
+${nested ? `
+class __PulseFastlyJsonCopyFrame {
+  index: i32 = 0
+  constructor(public input: i32, public output: i32) {}
+}
+function __pulse_fastly_json_copy_enter(handle: i32, duplicates: bool, frames: Array<__PulseFastlyJsonCopyFrame>): i32 {
+  const value = __pulse_fastly_value(handle)
+  if (value.kind != PULSE_VALUE_ARRAY && value.kind != PULSE_VALUE_OBJECT) return handle
+  if (duplicates && value.duplicateJsonKeys) { __pulse_fastly_fail(PULSE_ERROR_SCHEMA, 57, -1); return 0 }
+  const copy = value.kind == PULSE_VALUE_ARRAY ? host_value_array() : host_value_object()
+  frames.push(new __PulseFastlyJsonCopyFrame(handle, copy))
+  return copy
+}
+function __pulse_fastly_copy_json(handle: i32, duplicates: bool): i32 {
+  const frames = new Array<__PulseFastlyJsonCopyFrame>()
+  const output = __pulse_fastly_json_copy_enter(handle, duplicates, frames)
+  while (frames.length > 0) {
+    const frame = frames[frames.length - 1]
+    const value = __pulse_fastly_value(frame.input)
+    if (frame.index == value.values.length) { frames.pop(); continue }
+    const index = frame.index++
+    const copy = __pulse_fastly_json_copy_enter(value.values[index], duplicates, frames)
+    if (copy <= 0) return 0
+    if (value.kind == PULSE_VALUE_ARRAY) host_value_array_push(frame.output, copy)
+    else host_value_object_set(frame.output, __pulse_fastly_string_value(value.keys[index]), copy)
+  }
+  return output
+}
+` : ''}`;
+}
+
+module.exports = { hasJsonAdmission, tracksJsonDuplicates, schemaParserDepth, nestedJsonProjectionLines, schemaJsonAdmissionSource, schemaFetchJsonSource };

package/src/build/schema-scalar-record.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const { schemaHasScalarRecord } = require('@pulse-compute/wasm-contracts/schema-json/registry');
+
+function hasScalarRecords(plan) {
+  return (plan.schemas?.registry?.schemas || []).some(schema => schemaHasScalarRecord(schema.root));
+}
+
+// Both Fastly Native realizations validate handles before json-as sees them.
+function scalarRecordProjectionLines(node) {
+  const limits = node.limits;
+  return [
+    '  if (input.kind != PULSE_VALUE_OBJECT || (checkDuplicates && input.duplicateJsonKeys)) { __pulse_fastly_fail(PULSE_ERROR_SCHEMA, 56, -1); return 0 }',
+    `  if (input.keys.length > ${limits.maxKeys}) { __pulse_fastly_fail(PULSE_ERROR_SCHEMA, 56, -1); return 0 }`,
+    '  const keys = input.keys.slice().sort()',
+    '  const output = host_value_object()',
+    '  let bytes = 2',
+    '  for (let i = 0; i < keys.length; i++) {',
+    '    const key = keys[i]',
+    `    if (key.length > ${limits.maxKeyLength}) { __pulse_fastly_fail(PULSE_ERROR_SCHEMA, 56, -1); return 0 }`,
+    '    const keyHandle = __pulse_fastly_string_value(key)',
+    '    const itemHandle = host_value_property(valueHandle, keyHandle)',
+    '    const item = __pulse_fastly_value(itemHandle)',
+    '    let size = 0',
+    '    if (item.kind == PULSE_VALUE_STRING) {',
+    `      if (item.text.length > ${limits.maxStringLength}) { __pulse_fastly_fail(PULSE_ERROR_SCHEMA, 56, -1); return 0 }`,
+    '      size = __pulse_scalar_record_string_bytes(item.text)',
+    '    } else if (item.kind == PULSE_VALUE_NUMBER && isFinite(item.number)) {',
+    `      size = ${limits.numberBytes}`,
+    '    } else if (item.kind == PULSE_VALUE_BOOLEAN) size = item.boolean != 0 ? 4 : 5',
+    '    else if (item.kind == PULSE_VALUE_NULL) size = 4',
+    '    else { __pulse_fastly_fail(PULSE_ERROR_SCHEMA, 56, -1); return 0 }',
+    '    bytes += (i == 0 ? 0 : 1) + __pulse_scalar_record_string_bytes(key) + 1 + size',
+    `    if (bytes > ${limits.maxBytes}) { __pulse_fastly_fail(PULSE_ERROR_SCHEMA, 56, -1); return 0 }`,
+    '    host_value_object_set(output, keyHandle, itemHandle)',
+    '  }',
+    '  return output'
+  ];
+}
+
+module.exports = { hasScalarRecords, scalarRecordProjectionLines };

package/src/build/wasm-budget.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const { fastlyConfigDefault } = require('../config-schema.js');
+const DEFAULT_FASTLY_MAX_WASM_BYTES = fastlyConfigDefault('fastly.build.maxWasmBytes');
+
+function normalizeFastlyMaxWasmBytes(value) {
+  if (value === undefined) return DEFAULT_FASTLY_MAX_WASM_BYTES;
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    const error = new TypeError('fastly.build.maxWasmBytes must be a positive safe integer byte count.');
+    error.code = 'PULSE_FASTLY_MAX_WASM_BYTES_INVALID';
+    throw error;
+  }
+  return value;
+}
+
+function assertFastlyWasmBudget(bytes, value) {
+  const maxBytes = normalizeFastlyMaxWasmBytes(value);
+  if (bytes > maxBytes) {
+    const error = new Error('Generated Fastly Native module exceeds the configured Pulse compilation budget.');
+    error.name = 'FastlyNativePlatformCapabilitiesError';
+    error.code = 'PULSE_FASTLY_NATIVE_PLATFORM_CAPABILITIES_WASM_TOO_LARGE';
+    error.detail = Object.freeze({ bytes, maxBytes });
+    throw error;
+  }
+  return maxBytes;
+}
+
+module.exports = Object.freeze({ DEFAULT_FASTLY_MAX_WASM_BYTES, normalizeFastlyMaxWasmBytes, assertFastlyWasmBudget });

package/src/config-api.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const { normalizeFastlyMaxWasmBytes } = require('./build/wasm-budget.js');
 const { fastlyConfigDefault } = require('./config-schema.js');
 
 const FASTLY_PROVIDER_API_VERSION = 'pulse.provider-fastly-api.v2';
@@ -49,6 +50,7 @@ function fastly(options = {}) {
       dynamicBackends: options.dynamicBackends === undefined ? fastlyConfigDefault('fastly.dynamicBackends') : options.dynamicBackends === true
     }),
     build: Object.freeze({
+      maxWasmBytes: normalizeFastlyMaxWasmBytes(options.maxWasmBytes),
       name: String(options.name ?? fastlyConfigDefault('fastly.name')),
       description: String(options.description ?? fastlyConfigDefault('fastly.description')),
       authors: Object.freeze((Array.isArray(options.authors) ? options.authors : fastlyConfigDefault('fastly.authors')).map(String)),

package/src/config-schema.json

@@ -75,6 +75,13 @@
     },
     "fastly.maxDurationMs": {
       "kind": "optional-number"
+    },
+    "fastly.build.maxWasmBytes": {
+      "kind": "positive-safe-integer",
+      "default": 4194304
+    },
+    "fastly.maxWasmBytes": {
+      "kind": "positive-safe-integer"
     }
   }
 }