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

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

@@ -0,0 +1,50 @@
+// 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; }
+const __request_clock_result = new StaticArray<i64>(1);
+function __request_clock(): i64 {
+  const out = __request_clock_result;
+  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,47 @@
+'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 == 1 && __pulse_fetch_has_deadlines()) && kind != 12 && kind != 13 && kind != 14 && kind != 21 && ${plan.effects.filter(e=>e.kind.startsWith('kv.')&&['kv.getVersioned','kv.insertIfAbsent','kv.compareAndSwap','kv.list','kv.delete'].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;');
+  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;');
+  replace('function __pulse_fetch_request_check(index: i32): bool { return true }', 'function __pulse_fetch_request_check(index: i32): bool { return __request_check(index) }');
+  replace('function __pulse_fetch_request_remaining(): i32 { return 2147483647 }', 'function __pulse_fetch_request_remaining(): i32 { return __request_remaining() }');
+  if (plan.callables?.length || plan.binaryResources || plan.numericWorkspaces?.length) replace('function __pulse_resource_request_check(): bool { return true }', 'function __pulse_resource_request_check(): bool { return __request_check() }');
+  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

@@ -0,0 +1,228 @@
+// Provider-owned lifecycle and host ABI. Protocol algorithms are S3-owned.
+@external('fastly_async_io', 'select') declare function __s3_select(handles: usize, count: i32, timeout: i32, done: usize): i32
+@external('fastly_http_req', 'pending_req_poll_v2') declare function __s3_poll(pending: i32, detail: usize, done: usize, response: usize, body: usize): i32
+@external('fastly_http_req', 'cache_override_set') declare function __s3_cache(request: i32, tag: i32, ttl: i32, swr: i32): i32
+@external('fastly_http_req', 'auto_decompress_response_set') declare function __s3_decompress(request: i32, encodings: i32): i32
+@external('fastly_http_req', 'close') declare function __s3_close_req(request: i32): i32
+@external('fastly_http_resp', 'close') declare function __s3_close_resp(response: i32): i32
+@external('fastly_http_body', 'close') declare function __s3_close_body(body: i32): i32
+@external('fastly_http_resp', 'header_names_get') declare function __s3_header_names(response: i32, buffer: usize, size: i32, cursor: i32, end: usize, written: usize): i32
+@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;
+}
+@lazy const __s3_dispatched = new StaticArray<bool>(PULSE_FASTLY_EFFECT_COUNT)
+@lazy const __s3_sent_bytes = new StaticArray<i32>(PULSE_FASTLY_EFFECT_COUNT)
+@lazy const __s3_digests = new Array<string>(PULSE_FASTLY_EFFECT_COUNT).fill('')
+@lazy const __s3_deadlines = new StaticArray<i64>(PULSE_FASTLY_EFFECT_COUNT)
+function __s3_clock(id: i32): i64 {
+  const out = new StaticArray<i64>(1);
+  return wasi_snapshot_preview1_clock_time_get(id, 1000000, changetype<usize>(out)) == 0 ? out[0] : -1;
+}
+function __s3_remaining(index: i32): i32 {
+  const now = __s3_clock(1);
+  if (now < 0) return 0;
+  const ns = __s3_deadlines[index] - now;
+  return ns <= 0 ? 0 : i32((ns + 999999) / 1000000);
+}
+function __s3_set(object: i32, name: string, value: i32): void { host_value_object_set(object, __pulse_fastly_string_value(name), value) }
+function __s3_result(status: string, reason: string = '', http: i32 = 0): i32 {
+  const result = host_value_object(); __s3_set(result, 'status', __pulse_fastly_string_value(status));
+  if (reason.length) __s3_set(result, 'reason', __pulse_fastly_string_value(reason));
+  if (http > 0) { const value = new __PulseFastlyValue(); value.kind = PULSE_VALUE_NUMBER; value.number = f64(http); __s3_set(result, 'httpStatus', __pulse_fastly_put(value)); }
+  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)) }
+function __s3_secret(store: i32, name: string): string | null {
+  const key = __pulse_s3_bytes(name), out = new StaticArray<i32>(1), size = new StaticArray<i32>(1), bytes = new Uint8Array(4096);
+  if (fastly_secret_store_get(store, key.dataStart, key.length, changetype<usize>(out)) != 0) return null;
+  const status = fastly_secret_store_plaintext(out[0], bytes.dataStart, bytes.length, changetype<usize>(size));
+  let result: string | null = null;
+  if (status == 0 && size[0] > 0 && size[0] <= bytes.length) {
+    const raw = bytes.subarray(0, size[0]);
+    if (__pulse_s3_utf8_valid(raw)) result = String.UTF8.decodeUnsafe(raw.dataStart, raw.length, false);
+  }
+  bytes.fill(0);
+  if (result !== null) __pulse_fastly_remember_secret(result);
+  return result;
+}
+function __s3_header(request: i32, name: string, value: string): bool {
+  const n = __pulse_s3_bytes(name), v = __pulse_s3_bytes(value);
+  return fastly_http_req_header_insert(request, n.dataStart, n.length, v.dataStart, v.length) == 0;
+}
+function __pulse_fastly_s3_begin(index: i32, outer: __PulseFastlyValue): void {
+  __pulse_transport_slots[index] = null;
+  __s3_dispatched[index] = false; __s3_sent_bytes[index] = 0; __s3_digests[index] = '';
+  const put = __pulse_fastly_effect_kind(index) == 14;
+  const payload = __pulse_fastly_value(__pulse_fastly_payload_field(outer, 'invocation'));
+  const input = __pulse_fastly_value(__pulse_fastly_payload_field(payload, 'key'));
+  if (input.kind != PULSE_VALUE_STRING) { __s3_fail(index, 'invalid-key'); return; }
+  const encoded = __pulse_s3_key(input.text);
+  if (encoded === null) { __s3_fail(index, 'invalid-key'); return; }
+  // Package effect payloads and signed paths must not enter provider logs.
+  __pulse_fastly_remember_secret(input.text);
+  const binding = __pulse_fastly_s3_binding(index), start = __s3_clock(1);
+  if (start < 0) { __s3_fail(index, 'configuration'); return; }
+  __s3_deadlines[index] = start + i64(binding.timeout) * 1000000;
+  let data = new Uint8Array(0);
+  if (put) {
+    const text = __pulse_fastly_value(__pulse_fastly_payload_field(payload, 'text'));
+    if (text.kind != PULSE_VALUE_STRING) { __s3_fail(index, 'invalid-text'); return; }
+    if (text.text.length > binding.max) { __s3_fail(index, 'too-large'); return; }
+    if (!__pulse_s3_scalar(text.text)) { __s3_fail(index, 'invalid-text'); return; }
+    data = __pulse_s3_bytes(text.text);
+    if (data.length > binding.max) { __s3_fail(index, 'too-large'); return; }
+    __pulse_fastly_remember_secret(text.text);
+  }
+  const storeName = __pulse_s3_bytes(__pulse_fastly_secret_store(index)), store = new StaticArray<i32>(1);
+  if (fastly_secret_store_open(storeName.dataStart, storeName.length, changetype<usize>(store)) != 0) { __s3_fail(index, 'credentials'); return; }
+  const id = __s3_secret(store[0], binding.id), secret = __s3_secret(store[0], binding.secret);
+  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 = 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, 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);
+  if (__s3_remaining(index) == 0) { __s3_fail(index, 'timeout'); return; }
+  const request = new StaticArray<i32>(1), body = new StaticArray<i32>(1), pending = new StaticArray<i32>(1);
+  if (fastly_http_req_new(changetype<usize>(request)) != 0) { __s3_fail(index, 'transport'); return; }
+  const req = request[0], url = __pulse_s3_bytes(binding.endpoint + path), verb = __pulse_s3_bytes(method), backend = __pulse_s3_bytes(binding.backend);
+  let ok = fastly_http_req_uri_set(req, url.dataStart, url.length) == 0 && fastly_http_req_method_set(req, verb.dataStart, verb.length) == 0
+    && __s3_cache(req, 1, 0, 0) == 0 && __s3_decompress(req, 0) == 0
+    && __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; }
+  let offset = 0; const written = new StaticArray<i32>(1);
+  while (offset < data.length) {
+    if (__s3_remaining(index) == 0) { __s3_close_req(req); __s3_close_body(body[0]); __s3_fail(index, 'timeout'); return; }
+    if (fastly_http_body_write(body[0], data.dataStart + offset, data.length - offset, 0, changetype<usize>(written)) != 0 || written[0] <= 0 || written[0] > data.length - offset) {
+      __s3_close_req(req); __s3_close_body(body[0]); __s3_fail(index, 'transport'); return;
+    }
+    offset += written[0];
+  }
+  if (__s3_remaining(index) == 0) { __s3_close_req(req); __s3_close_body(body[0]); __s3_fail(index, 'timeout'); return; }
+  __s3_dispatched[index] = true;
+  const sent = fastly_http_req_send_async(req, body[0], backend.dataStart, backend.length, changetype<usize>(pending));
+  if (sent != 0) {
+    __pulse_transport_capture(index, sent, 'send');
+    __s3_close_req(req); __s3_close_body(body[0]); __s3_fail(index, 'transport'); return;
+  }
+  // send_async consumes request/body. Pending handles have no cancel hostcall.
+  __pulse_fastly_pending[index] = pending[0]; __pulse_fastly_pending_mode[index] = PULSE_FASTLY_PENDING_ASYNC;
+}
+function __s3_wait_ready(index: i32, handle: i32): i32 {
+  const timeout = __s3_remaining(index); if (timeout == 0) return 0;
+  const handles = new StaticArray<i32>(1), done = new StaticArray<i32>(1); handles[0] = handle;
+  if (__s3_select(changetype<usize>(handles), 1, timeout, changetype<usize>(done)) != 0) return -1;
+  return done[0] == -1 || __s3_remaining(index) == 0 ? 0 : 1;
+}
+function __s3_list(buffer: Uint8Array, size: i32): Array<string> | null {
+  if (size < 0 || size > buffer.length || (size > 0 && buffer[size - 1] != 0)) return null;
+  const result = new Array<string>(); let start = 0;
+  for (let i = 0; i < size; i++) if (buffer[i] == 0) {
+    const bytes = buffer.subarray(start, i); if (!__pulse_s3_utf8_valid(bytes)) return null;
+    result.push(String.UTF8.decodeUnsafe(bytes.dataStart, bytes.length, false)); start = i + 1;
+  }
+  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');
+  if (status != 200 && !rejected) return __s3_failure(index, __pulse_s3_status_reason(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_failure(index, 'protocol', status);
+  const names = __s3_list(buffer, size[0]); if (names === null) return __s3_failure(index, 'protocol', status);
+  let total = 0, length: f64 = -1; const seen = new Set<string>();
+  const result = __s3_result(put ? 'stored' : 'found');
+  for (let i = 0; i < names.length; i++) {
+    const rawName = names[i], name = rawName.toLowerCase(), bytes = __pulse_s3_bytes(rawName);
+    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_failure(index, 'protocol', status);
+    const values = __s3_list(buffer, size[0]); if (values === null) return __s3_failure(index, 'protocol', status);
+    const selected = name == 'content-length' || name == 'content-type' || name == 'etag' || name == 'content-encoding';
+    if (selected && (seen.has(name) || values.length != 1)) return __s3_failure(index, 'protocol', status);
+    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_failure(index, 'protocol', status);
+      if (!selected) continue;
+      if (count > 1024 || !__pulse_s3_scalar(value, true)) return __s3_failure(index, 'protocol', status);
+      if (name == 'content-encoding' && value.toLowerCase() != 'identity') return __s3_failure(index, 'protocol', status);
+      if (name == 'content-length') {
+        if (!value.length || (value.length > 1 && value.charCodeAt(0) == 48)) return __s3_failure(index, 'protocol', status);
+        length = 0;
+        for (let c = 0; c < value.length; c++) { const digit = value.charCodeAt(c) - 48; if (digit < 0 || digit > 9) return __s3_failure(index, 'protocol', status); length = length * 10 + digit; if (length > 9007199254740991) return __s3_failure(index, 'protocol', status); }
+      }
+      if (name == 'etag') { if (!value.length) return __s3_failure(index, 'protocol', status); __s3_set(result, 'etag', __pulse_fastly_string_value(value)); }
+      if (name == 'content-type' && !put) __s3_set(result, 'contentType', __pulse_fastly_string_value(value));
+    }
+  }
+  if (__s3_remaining(index) == 0) return __s3_failure(index, 'timeout', status);
+  const head = __pulse_fastly_effect_kind(index) == 12, binding = __pulse_fastly_s3_binding(index);
+  if (head && length < 0) return __s3_failure(index, 'protocol', status);
+  if (!head) {
+    const maximum = put && !rejected ? 0 : binding.max;
+    if (length > maximum) return __s3_failure(index, put ? 'protocol' : 'too-large', status);
+    const data = new Uint8Array(maximum + 1); let count = 0;
+    while (true) {
+      const ready = __s3_wait_ready(index, body);
+      if (ready <= 0) return __s3_failure(index, ready == 0 ? 'timeout' : 'transport', status);
+      if (fastly_http_body_read(body, data.dataStart + count, data.length - count, changetype<usize>(size)) != 0) return __s3_failure(index, 'protocol', status);
+      if (size[0] < 0 || size[0] > data.length - count) return __s3_failure(index, 'protocol', status);
+      if (size[0] == 0) break;
+      count += size[0]; if (count > maximum) return __s3_failure(index, put ? 'protocol' : 'too-large', status);
+    }
+    if (length >= 0 && length != count) return __s3_failure(index, 'protocol', status);
+    if (put) {
+      if (__s3_remaining(index) == 0) return __s3_failure(index, 'timeout', status);
+      if (rejected) return __s3_result('not-stored', status == 401 || status == 403 ? 'not-authorized' : status == 429 ? 'throttled' : 'rejected', status);
+      const sent = new __PulseFastlyValue(); sent.kind = PULSE_VALUE_NUMBER; sent.number = f64(__s3_sent_bytes[index]);
+      __s3_set(result, 'byteLength', __pulse_fastly_put(sent));
+      __s3_set(result, 'sha256', __pulse_fastly_string_value(__s3_digests[index]));
+      return result;
+    }
+    length = f64(count); const raw = data.subarray(0, count), digest = __pulse_s3_hex(__pulse_s3_sha(raw));
+    if (!__pulse_s3_utf8_valid(raw)) return __s3_failure(index, 'invalid-utf8', status);
+    __s3_set(result, 'text', __pulse_fastly_string_value(String.UTF8.decodeUnsafe(raw.dataStart, raw.length, false)));
+    __s3_set(result, 'sha256', __pulse_fastly_string_value(digest));
+  }
+  if (__s3_remaining(index) == 0) return __s3_failure(index, 'timeout', status);
+  const sizeValue = new __PulseFastlyValue(); sizeValue.kind = PULSE_VALUE_NUMBER; sizeValue.number = length;
+  __s3_set(result, 'byteLength', __pulse_fastly_put(sizeValue)); return result;
+}
+function __pulse_fastly_s3_wait(index: i32): i32 {
+  if (__pulse_fastly_pending_mode[index] == PULSE_FASTLY_PENDING_READY) return __pulse_fastly_wait_ready(index);
+  const pending = __pulse_fastly_pending[index], detail = new StaticArray<i32>(__PULSE_SEND_ERROR_DETAIL_WORDS), done = new StaticArray<i32>(1);
+  const response = new StaticArray<i32>(1), body = new StaticArray<i32>(1), code = new StaticArray<i32>(1);
+  __pulse_fastly_pending_mode[index] = PULSE_FASTLY_PENDING_NONE; __pulse_fastly_pending[index] = 0;
+  while (true) {
+    const ready = __s3_wait_ready(index, pending);
+    if (ready <= 0) return __s3_failure(index, ready == 0 ? 'timeout' : 'transport');
+    done[0] = 0; __pulse_send_error_detail_reset(changetype<usize>(detail));
+    const status = __s3_poll(pending, changetype<usize>(detail), changetype<usize>(done), changetype<usize>(response), changetype<usize>(body));
+    if (status != 0) { __pulse_transport_capture(index, status, 'poll', changetype<usize>(detail)); return __s3_failure(index, 'transport'); }
+    if (done[0] != 0) break;
+  }
+  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]);
+  if (!__pulse_fastly_value(result).s3Body) __s3_close_body(body[0]);
+  __s3_close_resp(response[0]); return result;
+}

package/src/build/s3-native.js

@@ -0,0 +1,30 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const { pulseS3AssemblyScriptSource } = require('@pulse-compute/s3/pulsewasm-native');
+const S3_IMPORTS = Object.freeze([
+  'fastly_async_io:select', 'fastly_http_req:pending_req_poll_v2', 'fastly_http_req:cache_override_set',
+  'fastly_http_req:auto_decompress_response_set', 'fastly_http_req:close', 'fastly_http_resp:close', 'fastly_http_body:close',
+  'fastly_http_resp:header_names_get', 'fastly_http_resp:header_values_get', 'fastly_http_resp:status_get',
+  'fastly_http_req:new', 'fastly_http_req:method_set', 'fastly_http_req:uri_set', 'fastly_http_req:header_insert', 'fastly_http_req:send_async',
+  'fastly_http_body:new', 'fastly_http_body:read', 'fastly_http_body:write', 'fastly_secret_store:open', 'fastly_secret_store:get', 'fastly_secret_store:plaintext',
+  'wasi_snapshot_preview1:clock_time_get'
+]);
+function s3NativeSource(plan, bindings) {
+  if (!bindings.s3.length) return '';
+  const contribution = pulseS3AssemblyScriptSource();
+  for (const name of contribution.cryptoRequirements) {
+    const selected = plan.crypto && plan.crypto.algorithms.find((entry) => entry.algorithm === name);
+    if (!selected || selected.realization !== 'guest-source:pulse-hmac-as' || selected.implementation !== 'pulse-hmac-as.v1'
+      || selected.kind !== 'guest-source' || selected.targetImplemented !== true || selected.automaticFallback !== false) throw new TypeError('Fastly S3 requires its exact selected Native Crypto algorithms.');
+  }
+  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({ 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'), 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 (!__pulse_fastly_has_value(handle)) return budget.fail(12)
+  const value = __pulse_fastly_value(handle)
+  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_value(frame.handle)
+    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 };