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

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

@@ -0,0 +1,52 @@
+'use strict';
+
+// Preserve ordered pairs (including repeated names) in the existing key/value
+// carrier. Do not use object_set: it would replace duplicate keys.
+function fetchHeadersSource() {
+  return `
+function __pulse_fastly_fetch_header_valid(name: string, value: __PulseFastlyValue): bool {
+  if (name.length == 0 || value.kind != PULSE_VALUE_STRING) return false
+  for (let i = 0; i < name.length; i++) {
+    const c = name.charCodeAt(i)
+    if ((c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122)) continue
+    if ("!#$%&'*+-.^_\u0060|~".indexOf(name.charAt(i)) < 0) return false
+  }
+  for (let i = 0; i < value.text.length; i++) {
+    const c = value.text.charCodeAt(i)
+    if (c == 0 || c == 10 || c == 13 || c > 255) return false
+  }
+  return true
+}
+function __pulse_fastly_fetch_headers(input: __PulseFastlyValue, effectIndex: i32): __PulseFastlyValue {
+  const output = new __PulseFastlyValue()
+  output.kind = PULSE_VALUE_OBJECT
+  if (input.kind == PULSE_VALUE_UNDEFINED) return output
+  if (input.kind == PULSE_VALUE_OBJECT) {
+    for (let i = 0; i < input.keys.length; i++) {
+      if (!__pulse_fastly_fetch_header_valid(input.keys[i], __pulse_fastly_value(input.values[i]))) {
+        __pulse_fastly_fail(PULSE_ERROR_VALUE, 74, effectIndex); return output
+      }
+    }
+    return input
+  }
+  if (input.kind == PULSE_VALUE_ARRAY) {
+    for (let i = 0; i < input.values.length; i++) {
+      const pair = __pulse_fastly_value(input.values[i])
+      if (pair.kind != PULSE_VALUE_ARRAY || pair.values.length != 2) {
+        __pulse_fastly_fail(PULSE_ERROR_VALUE, 74, effectIndex); return output
+      }
+      const name = __pulse_fastly_value(pair.values[0])
+      if (name.kind != PULSE_VALUE_STRING || !__pulse_fastly_fetch_header_valid(name.text, __pulse_fastly_value(pair.values[1]))) {
+        __pulse_fastly_fail(PULSE_ERROR_VALUE, 74, effectIndex); return output
+      }
+      output.keys.push(name.text); output.values.push(pair.values[1])
+    }
+    return output
+  }
+  __pulse_fastly_fail(PULSE_ERROR_VALUE, 74, effectIndex)
+  return output
+}
+`;
+}
+
+module.exports = { fetchHeadersSource };

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

@@ -0,0 +1,87 @@
+'use strict';
+
+function instrument(input, plan) {
+  const selected = plan.effects.flatMap((effect, index) => effect.kind === 'fetch' && effect.fetchErrors === 'collect' ? [index] : []);
+  const wrapped = plan.effects.flatMap((effect,index)=>effect.kind==='fetch' && (effect.fetchErrors==='collect'||effect.fetchTiming) ? [index] : []);
+  const hasTiming = plan.effects.some(effect=>effect.fetchTiming);
+  let source = input;
+  const replace = (before, after) => {
+    if (source.split(before).length !== 2) throw Error('Fetch outcome boundary drift: ' + before);
+    source = source.replace(before, after);
+  };
+  // Even an unselected operation may receive a dynamic init object. Fail closed
+  // if it tries to change the statically planned result shape before dispatch.
+  const selectedIndex = selected.map(i => `effectIndex == ${i}`).join(' || ') || 'false';
+  const anchor = 'headers.kind = PULSE_VALUE_OBJECT; if (init.kind == PULSE_VALUE_OBJECT) {';
+  replace(anchor, anchor + `
+    const errorsIndex = __pulse_fastly_find(init, 'errors');
+    const errors = errorsIndex >= 0 ? __pulse_fastly_value(init.values[errorsIndex]) : new __PulseFastlyValue();
+    const collect = errors.kind == PULSE_VALUE_STRING && errors.text == 'collect';
+    if ((errorsIndex >= 0 && errors.kind != PULSE_VALUE_UNDEFINED && !collect) || collect != (${selectedIndex})) {
+      __pulse_fastly_fail(PULSE_ERROR_VALUE, 48, effectIndex); return;
+    }
+  `);
+  if (!wrapped.length) return source;
+  replace('function __pulse_fastly_fetch_begin(effectIndex: i32, payload: __PulseFastlyValue): void {',
+    'function __pulse_fetch_begin_uncollected(effectIndex: i32, payload: __PulseFastlyValue): void {');
+  replace('function __pulse_fastly_resolve_effect(effectIndex: i32): i32 {',
+    'function __pulse_fetch_resolve_uncollected(effectIndex: i32): i32 {');
+  // Keep host status available only while an explicitly selected fetch projection
+  // runs. Schema, invalid handle/ABI and request-body errors stay fatal.
+  replace('if (status != FASTLY_STATUS_OK) { __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 20, effectIndex); return "" }',
+    'if (status != FASTLY_STATUS_OK) { if (__pulse_fetch_projecting >= 0) __pulse_fetch_fail(status, 20, __pulse_fetch_projecting); else __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 20, effectIndex); return "" }');
+  source += `
+// Per-site storage is reset on every admission; it never outlives invocation ownership.
+const __pulse_fetch_collected_failure = new StaticArray<i32>(PULSE_FASTLY_EFFECT_COUNT)
+let __pulse_fetch_projecting: i32 = -1
+function __pulse_fetch_collects(index: i32): bool { return ${selected.map(i => `index == ${i}`).join(' || ') || 'false'} }
+function __pulse_fetch_wraps(index: i32): bool { return ${wrapped.map(i => `index == ${i}`).join(' || ')} }
+function __pulse_fetch_envelope(index: i32, value: i32, timeout: bool = false, rejected: bool = false): i32 {
+  const result = host_value_object()
+  host_value_object_set(result, __pulse_fastly_string_value('status'), __pulse_fastly_string_value(rejected ? 'rejected' : 'fulfilled'))
+  if (rejected) {
+    const error = host_value_object()
+    host_value_object_set(error, __pulse_fastly_string_value('code'), __pulse_fastly_string_value(timeout ? 'PULSE_FETCH_TIMEOUT' : 'PULSE_FETCH_NETWORK'))
+    host_value_object_set(result, __pulse_fastly_string_value('error'), error)
+  } else host_value_object_set(result, __pulse_fastly_string_value('value'), value)
+  ${hasTiming ? "if (__pulse_timing_selected(index)) host_value_object_set(result, __pulse_fastly_string_value('elapsedMs'), __pulse_timing_elapsed(index))" : ''}
+  return result
+}
+function __pulse_fetch_collect_failure(index: i32): i32 {
+  if (!__pulse_fetch_collects(index) || !__pulse_fetch_request_check(index)) return 0
+  const stage = __pulse_fastly_error_stage
+  if (__pulse_fastly_last_error != PULSE_ERROR_TRANSPORT || __pulse_fastly_error_effect != index
+    || (stage != 77 && stage != 81 && stage != 271 && stage != 20)) return 0
+  __pulse_fastly_last_error = 0; __pulse_fastly_error_stage = 0; __pulse_fastly_error_effect = -1
+  return __pulse_fetch_envelope(index, 0, stage == 271, true)
+}
+function __pulse_fastly_fetch_begin(effectIndex: i32, payload: __PulseFastlyValue): void {
+  __pulse_fetch_collected_failure[effectIndex] = 0
+  __pulse_fetch_begin_uncollected(effectIndex, payload)
+  if (__pulse_fastly_last_error == 0) return
+  const failure = __pulse_fetch_collect_failure(effectIndex)
+  if (failure <= 0) return
+  __pulse_fetch_collected_failure[effectIndex] = failure
+  __pulse_fastly_ready_effect(effectIndex, failure)
+}
+function __pulse_fastly_resolve_effect(effectIndex: i32): i32 {
+  const saved = __pulse_fetch_collected_failure[effectIndex]
+  if (saved > 0) {
+    if (!__pulse_fetch_request_check(effectIndex)) return 0
+    __pulse_fetch_collected_failure[effectIndex] = 0
+    __pulse_fastly_pending_mode[effectIndex] = PULSE_FASTLY_PENDING_NONE
+    __pulse_fastly_ready[effectIndex] = 0
+    return saved
+  }
+  if (__pulse_fetch_wraps(effectIndex)) __pulse_fetch_projecting = effectIndex
+  const value = __pulse_fetch_resolve_uncollected(effectIndex)
+  __pulse_fetch_projecting = -1
+  if (!__pulse_fetch_wraps(effectIndex)) return value
+  if (!__pulse_fetch_request_check(effectIndex)) return 0
+  if (__pulse_fastly_last_error != 0) return __pulse_fetch_collect_failure(effectIndex)
+  return value > 0 ? __pulse_fetch_envelope(effectIndex, value) : 0
+}
+`;
+  return source;
+}
+module.exports = { instrument };

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

@@ -0,0 +1,74 @@
+// Optional transport observations reuse the fetch driver's existing wait set.
+@external('fastly_async_io', 'is_ready') declare function __pulse_timing_ready(handle:i32,out:usize):i32
+const __pulse_timing_starts = new StaticArray<i64>(PULSE_FASTLY_EFFECT_COUNT)
+const __pulse_timing_ends = new StaticArray<i64>(PULSE_FASTLY_EFFECT_COUNT)
+const __pulse_timing_clock_out = new StaticArray<i64>(1)
+const __pulse_timing_io = new StaticArray<i32>(1)
+class __PulseTimedBody {
+  value:i32; bytes:Uint8Array; total:i32=0; done:bool=false; last:i64=-2;
+  constructor(value:i32) { this.value=value; this.bytes=new Uint8Array(__PULSE_SCHEMA_MAX_BYTES+1); }
+}
+const __pulse_timing_bodies = new Array<__PulseTimedBody|null>(PULSE_FASTLY_EFFECT_COUNT)
+function __pulse_timing_selected(index:i32):bool { return /*TIMED*/ }
+function __pulse_timing_projected(index:i32):bool { return /*PROJECTED*/ }
+function __pulse_timing_clock():i64 {
+  if(wasi_snapshot_preview1_clock_time_get(1,1,changetype<usize>(__pulse_timing_clock_out))!=0)return -1;
+  return __pulse_timing_clock_out[0]>=0?__pulse_timing_clock_out[0]:-1;
+}
+function __pulse_timing_reset(index:i32):void {
+  __pulse_timing_starts[index]=-1; __pulse_timing_ends[index]=-2; __pulse_timing_bodies[index]=null;
+}
+function __pulse_timing_begin(index:i32):void { if(__pulse_timing_selected(index))__pulse_timing_starts[index]=__pulse_timing_clock(); }
+function __pulse_timing_end(index:i32):void { if(__pulse_timing_selected(index)&&__pulse_timing_ends[index]==-2)__pulse_timing_ends[index]=__pulse_timing_clock(); }
+function __pulse_timing_elapsed(index:i32):i32 {
+  const a=__pulse_timing_starts[index],b=__pulse_timing_ends[index];
+  return a<0||b<a?host_value_null():host_value_number(f64(b-a)/1000000.0);
+}
+function __pulse_timing_active():bool {
+  for(let i=0;i<PULSE_FASTLY_EFFECT_COUNT;i++) {
+    if(__pulse_timing_selected(i)&&__pulse_fetch_active(i))return true;
+    const row=__pulse_timing_bodies[i];if(row!==null&&!row.done)return true;
+  }
+  return false;
+}
+function __pulse_timing_headers(index:i32,value:i32):void {
+  if(!__pulse_timing_projected(index)){__pulse_fetch_complete(index,0,value);return;}
+  if(__PULSE_SCHEMA_MAX_BYTES<=0||__PULSE_SCHEMA_MAX_BYTES>1073741823){__pulse_fastly_fail(PULSE_ERROR_SCHEMA,21,index);return;}
+  // The member timeout ends at headers; enclosing authority still fences reads.
+  __pulse_fetch_timeout[index]=0;
+  __pulse_fastly_pending_mode[index]=PULSE_FASTLY_PENDING_READY;
+  __pulse_fastly_pending[index]=0;
+  __pulse_timing_bodies[index]=new __PulseTimedBody(value);
+}
+function __pulse_timing_read_round():void {
+  const out=__pulse_timing_io;
+  for(let i=0;i<PULSE_FASTLY_EFFECT_COUNT;i++) {
+    const row=__pulse_timing_bodies[i]; if(row===null||row.done)continue;
+    if(!__pulse_fetch_request_check(i))return;
+    const value=__pulse_fastly_value(row.value);
+    out[0]=-1;
+    if(__pulse_timing_ready(value.bodyHandle,changetype<usize>(out))!=0||out[0]<0||out[0]>1){__pulse_fastly_fail(PULSE_ERROR_HOSTCALL,272,i);return;}
+    if(out[0]==0)continue;
+    const capacity=min<i32>(PULSE_FASTLY_BUFFER_BYTES,row.bytes.length-row.total);
+    out[0]=-1;
+    const status=fastly_http_body_read(value.bodyHandle,row.bytes.dataStart+row.total,capacity,changetype<usize>(out));
+    if(status!=0){row.done=true;__pulse_fetch_complete(i,status);continue;}
+    if(out[0]<0||out[0]>capacity){__pulse_fastly_fail(PULSE_ERROR_HOSTCALL,20,i);return;}
+    if(out[0]==0){row.done=true;if(row.last!=-2)__pulse_timing_ends[i]=row.last;__pulse_fetch_complete(i,0,row.value);continue;}
+    const sample=__pulse_timing_clock();
+    row.last=row.last==-1||sample<row.last?-1:sample;
+    row.total+=out[0];
+    if(row.total>__PULSE_SCHEMA_MAX_BYTES){__pulse_fastly_fail(PULSE_ERROR_SCHEMA,21,i);return;}
+  }
+}
+function __pulse_timing_decode(value:__PulseFastlyValue):bool {
+  if(value.bodyLoaded!=0)return true;
+  for(let i=0;i<PULSE_FASTLY_EFFECT_COUNT;i++) {
+    const row=__pulse_timing_bodies[i];
+    if(row!==null&&row.done&&__pulse_fastly_value(row.value)===value){
+      value.text=__pulse_fastly_decode(row.bytes,row.total);value.bodyLoaded=1;
+      __pulse_timing_bodies[i]=null;return true;
+    }
+  }
+  return false;
+}

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

@@ -0,0 +1,50 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+function instrument(input, plan) {
+  const timed = plan.effects.flatMap((e,i)=>e.kind==='fetch' && e.fetchTiming ? [i] : []);
+  const projected = timed.filter(i=>plan.effects[i].decoder);
+  let source = input;
+  const replace = (a,b) => { if(source.split(a).length!==2)throw Error('Fetch timing boundary drift: '+a);source=source.replace(a,b); };
+  const selected = index => timed.map(i=>`${index} == ${i}`).join(' || ') || 'false';
+  // Dynamic init must not introduce optional instrumentation after compilation.
+  const anchor = 'headers.kind = PULSE_VALUE_OBJECT; if (init.kind == PULSE_VALUE_OBJECT) {';
+  replace(anchor, anchor+`
+    const timingIndex = __pulse_fastly_find(init, 'timing');
+    const timing = timingIndex >= 0 ? __pulse_fastly_value(init.values[timingIndex]) : new __PulseFastlyValue();
+    if ((timingIndex >= 0 && timing.kind != PULSE_VALUE_UNDEFINED && timing.kind != PULSE_VALUE_BOOLEAN)
+      || (timing.kind == PULSE_VALUE_BOOLEAN && timing.boolean) != (${selected('effectIndex')})) {
+      __pulse_fastly_fail(PULSE_ERROR_VALUE, 48, effectIndex); return;
+    }
+  `);
+  if(!timed.length)return source;
+  replace('function __pulse_fetch_begin_deadline(index: i32, init: __PulseFastlyValue): void {',
+    'function __pulse_fetch_begin_deadline(index: i32, init: __PulseFastlyValue): void { __pulse_timing_reset(index);');
+  replace('status = fastly_http_req_send_async(requestHandle, bodyHandle,',
+    '__pulse_timing_begin(effectIndex); status = fastly_http_req_send_async(requestHandle, bodyHandle,');
+  replace('function __pulse_fetch_has_deadlines(): bool {',
+    'function __pulse_fetch_has_deadlines(): bool { if (__pulse_timing_active()) return true;');
+  replace('function __pulse_fetch_complete(index: i32, outcome: i32, result: i32 = 0): void {',
+    'function __pulse_fetch_complete(index: i32, outcome: i32, result: i32 = 0): void { __pulse_timing_end(index);');
+  replace('__pulse_fetch_complete(i, 0, __pulse_fastly_put(value)); continue',
+    '__pulse_timing_headers(i, __pulse_fastly_put(value)); continue');
+  replace('while (!__pulse_fetch_completed[index]) {',
+    'while (!__pulse_fetch_completed[index] || __pulse_timing_active()) {');
+  // Both early-return fences must wait for transport observations, never decoding.
+  source=source.replaceAll('if (__pulse_fetch_completed[index]) break',
+    'if (__pulse_fetch_completed[index] && !__pulse_timing_active()) break');
+  replace('    if (__pulse_fetch_completed[index] && !__pulse_timing_active()) break\n    if (!__pulse_fetch_request_check(index))',
+    '    __pulse_timing_read_round(); if (__pulse_fastly_last_error != 0) return 0;\n    if (__pulse_fetch_completed[index] && !__pulse_timing_active()) break\n    if (!__pulse_fetch_request_check(index))');
+  // Add active bodies to the same wait set. One pending request OR body per site.
+  replace('    remaining = Math.min(remaining, f64(__pulse_fetch_request_remaining()))',
+    '    for (let i = 0; i < PULSE_FASTLY_EFFECT_COUNT; i++) { const row = __pulse_timing_bodies[i]; if (row !== null && !row.done) handles[count++] = __pulse_fastly_value(row.value).bodyHandle; }\n    remaining = Math.min(remaining, f64(__pulse_fetch_request_remaining()))');
+  replace('function __pulse_fastly_fetch_body(value: __PulseFastlyValue): string {',
+    'function __pulse_fastly_fetch_body(value: __PulseFastlyValue): string { if (__pulse_timing_decode(value)) return value.text;');
+  replace('const failure = __pulse_fetch_collect_failure(effectIndex)',
+    '__pulse_timing_end(effectIndex); const failure = __pulse_fetch_collect_failure(effectIndex)');
+  source += fs.readFileSync(path.join(__dirname,'native-fetch-timing.as.ts'),'utf8')
+    .replace('/*TIMED*/',selected('index'))
+    .replace('/*PROJECTED*/',projected.map(i=>`index == ${i}`).join(' || ') || 'false');
+  return source;
+}
+module.exports = { instrument };

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

@@ -0,0 +1,153 @@
+// One ledger is bound to this Wasm instance's single managed invocation. Raw
+// memory/ABI access is trusted; no scalar resource identity crosses the host ABI.
+// The entry guard prevents reuse; this closed, one-cohort profile never recycles
+// slots. Descriptor positions/generation 1 are validated at the commit boundary.
+let __fwd_ra: PulseResourceLedger | null = null;
+let __fra_origin: i64 = 0;
+let __fra_clock_failed: bool = false;
+let __fra_reaped: bool = false;
+function __fra_ns(slot: i32): u32 {
+  return slot == 0 || slot == 2 ? 1 : slot == 4 ? 4 : slot == 5 || slot == 7 || slot == 9 ? 2 : 3;
+}
+function __fra_now(): u64 {
+  if (__fra_clock_failed) return PRL_SAFE + 1;
+  const now = __request_clock();
+  if (now < __fra_origin || __request_expired) { __fra_clock_failed = true; return PRL_SAFE + 1; }
+  return u64(now - __fra_origin);
+}
+function __fra_ok(ok: bool): bool {
+  if (!ok) __fwd_fail(__request_expired ? 504 : 502);
+  return ok;
+}
+function __fra_start(): bool {
+  if (__fwd_ra !== null || __request_deadline < 0 || __request_last_clock < 0) return false;
+  __fra_origin = __request_deadline - i64(__FRA_DURATION);
+  const ledger = new PulseResourceLedger(1, 15, 11, __FRA_BACKING, 12, 1, __FRA_DURATION, __FRA_STORAGE);
+  __fwd_ra = ledger;
+  if (!ledger.begin(1, __fra_now(), 10, 2, 1, true)) return __fra_ok(false);
+  for (let i = 0; i < 11; i++)
+    if (!ledger.stageRecord(1, 1, __fra_ns(i), 1, i >= 9 ? 3 : 1, 0)) return __fra_ok(false);
+  if (!ledger.stageRecord(1, 2, 0, 1, 1, 33920)
+    || !ledger.stageRecord(1, 2, 0, 1, 1, __FRA_ENCODING)
+    || !ledger.stageRecord(1, 2, 0, 1, 3, 64)
+    || !ledger.stageRecord(1, 3, 0, 1, 1, 0)
+    || !ledger.commit(1, __fra_now())) return __fra_ok(false);
+  for (let i = 0; i < 15; i++)
+    if (ledger.reservedSlot(i) != i || ledger.reservedGeneration(i) != 1) return __fra_ok(false);
+  // Static scratch is present in the artifact, charged once before first use.
+  // Encoding allowance is consumed before any request/header UTF-8 allocation.
+  return __fra_ok(ledger.consume(1,11,1,1,33920,false,__fra_now())
+    && ledger.consume(1,12,1,1,__FRA_ENCODING,false,__fra_now()));
+}
+function __fra_acquire(slot: i32): bool {
+  return __fwd_ra !== null && __fra_ok(__fwd_ra!.beginAcquire(1,slot,1,__fra_ns(slot),1,slot >= 9,__fra_now()));
+}
+function __fra_acquired(slot: i32, status: i32, handle: i32): i32 {
+  const ledger = __fwd_ra!;
+  if (status == 0) __fra_ok(ledger.acquired(1,slot,1,__fra_ns(slot),1,u32(handle)));
+  else { ledger.noAcquisition(1,slot,1,__fra_ns(slot),1,false); __fwd_fail(502); }
+  return status;
+}
+function __fra_incoming(request: usize, body: usize): i32 {
+  if (!__fra_start() || !__fra_acquire(0) || !__fra_acquire(1)) return 1;
+  const status = fastly_http_req_body_downstream_get(request,body);
+  __fra_acquired(0,status,load<i32>(request)); __fra_acquired(1,status,load<i32>(body));
+  return status;
+}
+function __fra_new(slot: i32, out: usize): i32 {
+  if (!__fra_acquire(slot)) return 1;
+  const ns = __fra_ns(slot);
+  const status = ns == 1 ? fastly_http_req_new(out) : ns == 2 ? fastly_http_resp_new(out) : fastly_http_body_new(out);
+  return __fra_acquired(slot,status,load<i32>(out));
+}
+function __fra_dispose(slot: i32, abandon: bool = false): i32 {
+  if (__fwd_ra === null) return 1;
+  const ledger = __fwd_ra!, at = slot * 8;
+  if (ledger.bank[at+5] != PRL_LIVE) return 1;
+  // Disposal does not replace a primary error and never replenishes time.
+  if (!ledger.beginDispose(1,slot,1,__fra_ns(slot),1,__fra_now())) return 1;
+  const handle = i32(ledger.bank[at+6]), ns = __fra_ns(slot);
+  const status = ns == 1 ? __pulse_fetch_close_request(handle) : ns == 2 ? __pulse_fetch_close_response(handle)
+    : abandon ? __fwd_abandon(handle) : __pulse_fetch_close_body(handle);
+  ledger.disposed(1,slot,1,ns,1,status == 0);
+  return status;
+}
+function __fra_dispatch(request: i32, body: i32, backend: usize, length: i32, out: usize): i32 {
+  if (__pulse_invocation_count != 1 || __pulse_invocation_tickets[__fwd_index] != 1
+    || !__fra_acquire(4) || !__fra_acquire(5) || !__fra_acquire(6)) { __fwd_fail(502); return 1; }
+  const ledger = __fwd_ra!;
+  // Fence the possibly consumed request before send; upload stays guest-owned.
+  if (!ledger.beginDispose(1,2,1,1,1,__fra_now())) return 1;
+  const status = __fwd_dispatch(request,body,backend,length,out);
+  ledger.disposed(1,2,1,1,1,status == 0);
+  return __fra_acquired(4,status,load<i32>(out));
+}
+function __fra_poll(): i32 {
+  const ledger = __fwd_ra!;
+  // Outputs are fenced before dispatch and retained across qualified not-ready
+  // results. A failed/invalid poll is never retried, including during cleanup.
+  const status = __pulse_fetch_poll(__fwd_pending,__fwd_detail,__fwd_done,__fwd_response_out,__fwd_body_out);
+  const done = load<i32>(__fwd_done);
+  if (status != 0 || (done != 0 && done != 1)) {
+    ledger.uncertain(1,4,1,4,1);
+    ledger.noAcquisition(1,5,1,2,1,false); ledger.noAcquisition(1,6,1,3,1,false);
+    return status == 0 ? 1 : status;
+  }
+  if (done == 1) {
+    ledger.transferred(1,4,1,4,1);
+    __fra_acquired(5,0,load<i32>(__fwd_response_out)); __fra_acquired(6,0,load<i32>(__fwd_body_out));
+  }
+  return 0;
+}
+function __fra_send(response: i32, body: i32, streaming: i32): i32 {
+  const ledger = __fwd_ra!, r = streaming == 1 ? 7 : 9, b = streaming == 1 ? 8 : 10;
+  if (!ledger.beginDispose(1,r,1,2,1,__fra_now())) return 1;
+  if (streaming == 0 && !ledger.beginDispose(1,b,1,3,1,__fra_now())) return 1;
+  const status = fastly_http_resp_send_downstream(response,body,streaming);
+  ledger.disposed(1,r,1,2,1,status == 0);
+  if (streaming == 0) ledger.disposed(1,b,1,3,1,status == 0);
+  return status;
+}
+function __fra_cleanup(final: bool = false): void {
+  if (__fwd_ra === null) return;
+  const ledger = __fwd_ra!;
+  ledger.close(1);
+  // One reserved, nonblocking observation may adopt already-fenced outputs.
+  // Never retry unknown outcomes, acquire new claims, or extend the deadline.
+  if (!__fra_reaped && ledger.bank[4*8+5] == PRL_LIVE) {
+    __fra_reaped = true;
+    if (ledger.cleanupStep(1,false,__fra_now())) {
+      __pulse_send_error_detail_reset(__fwd_detail); store<i32>(__fwd_done,0);
+      __fra_poll();
+    }
+  }
+  // No pending-request cancel ABI. Remaining claims stay held for host teardown.
+  for (let slot = 0; slot < 11; slot++) {
+    const state = ledger.bank[slot*8+5];
+    if (state == PRL_RESERVED && (slot < 9 || final)) ledger.unused(1,slot,1,__fra_ns(slot),1);
+    else if (state == PRL_LIVE && slot != 4) __fra_dispose(slot,slot == 3 || slot == 8);
+  }
+}
+function __fra_error(status: i32): void {
+  if (__fwd_ra === null || !__pulse_response_owned()) return;
+  const ledger = __fwd_ra!;
+  if (!ledger.consume(1,13,1,1,64,true,__fra_now())) return;
+  // A fixed exit body uses the already-reserved scratch, without serialization
+  // or an application value allocation. Authority fences the one final send.
+  const text = status == 413 ? 'Payload Too Large' : status == 504 ? 'Gateway Timeout' : status == 400 ? 'Bad Request' : 'Bad Gateway';
+  if (__fra_new(9,__fwd_io+52) != 0) return;
+  const response = load<i32>(__fwd_io+52);
+  if (__fra_new(10,__fwd_io+52) != 0) return;
+  const body = load<i32>(__fwd_io+52);
+  if (__fra_now() >= __FRA_DURATION || fastly_http_resp_status_set(response,status) != 0) return;
+  for (let i = 0; i < text.length; i++) store<u8>(__fwd_buffer+i,u8(text.charCodeAt(i)));
+  let offset = 0;
+  while (offset < text.length) {
+    if (__fra_now() >= __FRA_DURATION) return;
+    const status = fastly_http_body_write(body,__fwd_buffer+offset,text.length-offset,0,__fwd_io+52);
+    const written = load<i32>(__fwd_io+52);
+    if (status != 0 || written <= 0 || written > text.length-offset) return;
+    offset += written;
+  }
+  if (__fra_send(response,body,0) == 0) __pulse_fastly_last_error = 0; // delivery handled; ledger primary remains
+}

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

@@ -0,0 +1,47 @@
+'use strict';
+// Trusted provider profile producer. Selection follows the existing canonical
+// forwarding validator; no authored profile, test limit or emitter callback.
+const fs = require('node:fs');
+const path = require('node:path');
+const { resourceAdmission: admission } = require('@pulse-compute/wasm-contracts/provider/toolchain');
+const { resourceLedgerSource } = require('@pulse-compute/wasm-runtime-core-as/compiler/canonical-native');
+const REALIZATION = 'fastly.native.forwarding.fixed-v1';
+const empty = () => ({ handles: [], allocations: [], records: 0, cleanupSteps: 0 });
+const fixed = (id, bytes) => ({ id, kind: 'fixed', bytes, copies: 1 });
+function profile(plan, bindings) {
+  if (!plan.capabilities.includes('request.body.forward')) return null;
+  const effect = plan.effects[0];
+  const init = effect.inputs.find(x => x.name === 'init').value;
+  const headers = init.entries.find(x => x.key.value === 'headers')?.value.entries || [];
+  const url = effect.inputs.find(x => x.name === 'url').value;
+  const backend = bindings.backends.find(x => x.index === 0)?.backend;
+  if (plan.effects.length !== 1 || effect.grouped || url.kind !== 'literal' || typeof url.value !== 'string'
+    || typeof backend !== 'string' || !backend || !Number.isInteger(bindings.maxDurationMs)
+    || bindings.maxDurationMs < 1 || bindings.maxDurationMs > 30000) throw new TypeError('Unproved forwarding accounting profile');
+  const encodingBytes = Buffer.byteLength(url.value) + Buffer.byteLength(backend)
+    + headers.reduce((n, h) => n + Buffer.byteLength(h.key.value) + Buffer.byteLength(h.value.value), 0);
+  const work = { handles: [{namespace:'http.request',count:2},{namespace:'http.body',count:4},
+    {namespace:'http.pending',count:1},{namespace:'http.response',count:2}],
+    allocations: [fixed('scratch',33920),fixed('encoding',encodingBytes)], records:1, cleanupSteps:0 };
+  const cleanup = {...empty(),cleanupSteps:10};
+  const exit = { handles:[{namespace:'http.response',count:1},{namespace:'http.body',count:1}],
+    allocations:[fixed('error-text',64)],records:0,cleanupSteps:2 };
+  const required = {handles:11,backingBytes:33984+encodingBytes,records:15,cleanupSteps:12,effects:1};
+  const result = admission.createPlan({version:admission.VERSION,realization:REALIZATION,
+    selected:[{site:'forward',count:1,profile:{version:admission.PROFILE_VERSION,owner:'provider-fastly',
+      operation:'bounded-forward',realization:REALIZATION,effects:1,work,cleanup,
+      exclusions:['request-context','value-wrappers','diagnostic-storage','driver-identity-storage','non-forwarding-driver-responses']}}],
+    exit,occupied:Object.fromEntries(admission.DIMENSIONS.map(k=>[k,0])),limits:required});
+  if (!result.admitted || Object.keys(required).some(k=>result.required[k]!==required[k])) throw new Error('Forwarding resource inventory drift');
+  const storageBytes = 1024 + result.required.records * 128;
+  if (storageBytes > 2147483647 || !Number.isSafeInteger(encodingBytes)) throw new RangeError('Forwarding resource representation');
+  return Object.freeze({ ...result, encodingBytes, storageBytes, durationNs:bindings.maxDurationMs*1000000,
+    selection:'canonical-terminal-forwarding', executionIdentity:'private-single-invocation-wasm-instance',
+    unprofiled:'general-fetch-decoding-cache-composition-and-javascript' });
+}
+function source(selected) {
+  if (!selected) return '';
+  return resourceLedgerSource(true) + `\nconst __FRA_ENCODING: u64 = ${selected.encodingBytes};\nconst __FRA_BACKING: u64 = ${selected.required.backingBytes};\nconst __FRA_STORAGE: u32 = ${selected.storageBytes};\nconst __FRA_DURATION: u64 = ${selected.durationNs};\n`
+    + fs.readFileSync(path.join(__dirname,'native-forwarding-accounting.as.ts'),'utf8');
+}
+module.exports = { profile, source };

package/src/build/native-header-lookup.js

@@ -39,11 +39,11 @@ function __pulse_header_send_error(): bool {
 }
 `;
 }
-function instrument(source) {
+function instrument(source, lifecycle) {
   source = source.replace(/function (host_\w+)\(([^)]*)\): (i32|void) \{/g,
     (declaration, name, _args, result) => name === 'host_router_error_take' ? declaration
       : `${declaration} if (__pulse_header_lookup_failed()) return${result === 'void' ? '' : ' 0'};`);
-  const marker = 'function __pulse_fastly_jwt_send_error(): void {';
+  const marker = `function ${lifecycle?.legacyName('__pulse_fastly_jwt_send_error') || '__pulse_fastly_jwt_send_error'}(): void {`;
   if (!source.includes(marker)) throw new Error('Fastly header-lookup error boundary drift.');
   return source.replace(marker, marker + ' if (__pulse_header_send_error()) return;');
 }

package/src/build/native-http-effects.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { fetchHeadersSource } = require('./native-fetch-headers.js');
+
 const dynamicBackends = require('./native-dynamic-backends.js');
 
 const { scalarRecordProjectionLines } = require('./schema-scalar-record.js');
@@ -52,7 +54,7 @@ const FASTLY_NATIVE_HTTP_EFFECTS_IMPORTS = Object.freeze([
   Object.freeze(['fastly_http_req', 'new']),
   Object.freeze(['fastly_http_req', 'method_set']),
   Object.freeze(['fastly_http_req', 'uri_set']),
-  Object.freeze(['fastly_http_req', 'header_insert']),
+  Object.freeze(['fastly_http_req', 'header_append']),
   Object.freeze(['fastly_http_req', 'send_async']),
   Object.freeze(['fastly_http_req', 'pending_req_wait']),
   Object.freeze(['fastly_http_resp', 'new']),
@@ -127,6 +129,9 @@ function validatePlanBoundary(plan) {
   if (packageEffects.length > 0) {
     fail('Pass97 does not realize package-owned Fastly effects; config, secret, KV, and GRIP are introduced in Pass98.', 'PULSE_FASTLY_NATIVE_HTTP_PLATFORM_EFFECTS_DEFERRED', { effects: packageEffects.map((entry) => entry.id) });
   }
+  if (plan.effects?.some(effect => effect.fetchErrors || effect.fetchTiming)) {
+    fail('Collected fetch outcomes require the canonical platform realization.', 'PULSE_FASTLY_NATIVE_HTTP_EFFECT_KIND_UNSUPPORTED');
+  }
   const unsupported = (plan.effects || []).filter((effect) => effect.kind !== 'fetch');
   if (unsupported.length > 0) {
     fail('Pass97 realizes only outbound HTTP fetch effects.', 'PULSE_FASTLY_NATIVE_HTTP_EFFECT_KIND_UNSUPPORTED', { effects: unsupported.map((entry) => ({ id: entry.id, kind: entry.kind })) });
@@ -277,6 +282,7 @@ function generateSchemaRuntime(plan) {
     `const __PULSE_SCHEMA_REQUIRE_JSON: bool = ${registry.contentTypePolicy === 'require-json' ? 'true' : 'false'}`,
     '',
     schemaJsonAdmissionSource(plan),
+    fetchHeadersSource(),
     schemaFetchJsonSource(),
     ...nodeLines,
     'function __pulse_fastly_schema_apply(schemaId: string, valueHandle: i32, encode: bool): i32 {',
@@ -341,7 +347,7 @@ function fastlyRuntimeSource(plan, bindings) {
 @external("fastly_http_req", "new") declare function fastly_http_req_new(handleOut: usize): i32
 @external("fastly_http_req", "method_set") declare function fastly_http_req_method_set(handle: i32, method: usize, methodLength: i32): i32
 @external("fastly_http_req", "uri_set") declare function fastly_http_req_uri_set(handle: i32, uri: usize, uriLength: i32): i32
-@external("fastly_http_req", "header_insert") declare function fastly_http_req_header_insert(handle: i32, name: usize, nameLength: i32, value: usize, valueLength: i32): i32
+@external("fastly_http_req", "header_append") declare function fastly_http_req_header_append(handle: i32, name: usize, nameLength: i32, value: usize, valueLength: i32): i32
 @external("fastly_http_req", "send_async") declare function fastly_http_req_send_async(handle: i32, body: i32, backend: usize, backendLength: i32, pendingOut: usize): i32
 @external("fastly_http_req", "pending_req_wait") declare function fastly_http_req_pending_req_wait(handle: i32, responseOut: usize, bodyOut: usize): i32
 @external("fastly_http_resp", "new") declare function fastly_http_resp_new(handleOut: usize): i32
@@ -682,7 +688,7 @@ function host_kv_namespace(name: i32): i32 { __pulse_fastly_fail(PULSE_ERROR_UNS
 function host_fetch_text(responseHandle: i32): i32 { const response = __pulse_fastly_value(responseHandle); if (response.kind != PULSE_VALUE_FETCH) { __pulse_fastly_fail(PULSE_ERROR_VALUE, 42, -1); return 0 } return __pulse_fastly_string_value(__pulse_fastly_fetch_body(response)) }
 function host_fetch_json(responseHandle: i32, schemaHandle: i32): i32 { const response = __pulse_fastly_value(responseHandle); if (response.kind != PULSE_VALUE_FETCH) { __pulse_fastly_fail(PULSE_ERROR_VALUE, 43, -1); return 0 } if (__PULSE_SCHEMA_REQUIRE_JSON) { const contentType = __pulse_fastly_fetch_header_text(response.responseHandle, "content-type"); if (contentType.length == 0 || contentType.toLowerCase().indexOf("json") < 0) { __pulse_fastly_fail(PULSE_ERROR_SCHEMA, 44, -1); return 0 } } const parsed = ${hasJsonAdmission(plan) ? '__pulse_fastly_schema_parse_json(__pulse_fastly_fetch_body(response), schemaHandle)' : '__pulse_fastly_parse_json(__pulse_fastly_fetch_body(response))'}; if (parsed <= 0) return 0; const schema = __pulse_fastly_value(schemaHandle); return schema.kind == PULSE_VALUE_STRING ? __pulse_fastly_schema_apply(schema.text, parsed, false) : parsed }
 function host_fetch_header(responseHandle: i32, nameHandle: i32): i32 { const response = __pulse_fastly_value(responseHandle); if (response.kind != PULSE_VALUE_FETCH) { __pulse_fastly_fail(PULSE_ERROR_VALUE, 45, -1); return 0 } const value = __pulse_fastly_fetch_header_text(response.responseHandle, __pulse_fastly_string(nameHandle)); return value.length == 0 ? host_value_undefined() : __pulse_fastly_string_value(value) }
-function host_effect_begin(effectIndex: i32, payload: i32): void { ${needsNativeValueFailureGuard(plan) ? 'if (__pulse_fastly_last_error != PULSE_ERROR_NONE) return; ' : ''}if (effectIndex < 0 || effectIndex >= PULSE_FASTLY_EFFECT_COUNT || unchecked(__pulse_fastly_pending_active[effectIndex]) != 0) { __pulse_fastly_fail(PULSE_ERROR_STATE, 46, effectIndex); return } const payloadValue = __pulse_fastly_value(payload); if (payloadValue.kind != PULSE_VALUE_OBJECT) { __pulse_fastly_fail(PULSE_ERROR_VALUE, 47, effectIndex); return } const urlIndex = __pulse_fastly_find(payloadValue, "url"); if (urlIndex < 0) { __pulse_fastly_fail(PULSE_ERROR_VALUE, 48, effectIndex); return } const url = __pulse_fastly_string(unchecked(payloadValue.values[urlIndex])); const initIndex = __pulse_fastly_find(payloadValue, "init"); const init = initIndex >= 0 ? __pulse_fastly_value(unchecked(payloadValue.values[initIndex])) : new __PulseFastlyValue(); let method = "GET"; let body = ""; let headers = new __PulseFastlyValue(); headers.kind = PULSE_VALUE_OBJECT; if (init.kind == PULSE_VALUE_OBJECT) { const methodIndex = __pulse_fastly_find(init, "method"); if (methodIndex >= 0) method = __pulse_fastly_string(unchecked(init.values[methodIndex])).toUpperCase(); const headersIndex = __pulse_fastly_find(init, "headers"); if (headersIndex >= 0) headers = __pulse_fastly_value(unchecked(init.values[headersIndex])); const bodyIndex = __pulse_fastly_find(init, "body"); if (bodyIndex >= 0) { const bodyValue = unchecked(init.values[bodyIndex]); const bodyObject = __pulse_fastly_value(bodyValue); body = bodyObject.kind == PULSE_VALUE_STRING ? bodyObject.text : __pulse_fastly_json(bodyValue, 0) }
+function host_effect_begin(effectIndex: i32, payload: i32): void { ${needsNativeValueFailureGuard(plan) ? 'if (__pulse_fastly_last_error != PULSE_ERROR_NONE) return; ' : ''}if (effectIndex < 0 || effectIndex >= PULSE_FASTLY_EFFECT_COUNT || unchecked(__pulse_fastly_pending_active[effectIndex]) != 0) { __pulse_fastly_fail(PULSE_ERROR_STATE, 46, effectIndex); return } const payloadValue = __pulse_fastly_value(payload); if (payloadValue.kind != PULSE_VALUE_OBJECT) { __pulse_fastly_fail(PULSE_ERROR_VALUE, 47, effectIndex); return } const urlIndex = __pulse_fastly_find(payloadValue, "url"); if (urlIndex < 0) { __pulse_fastly_fail(PULSE_ERROR_VALUE, 48, effectIndex); return } const url = __pulse_fastly_string(unchecked(payloadValue.values[urlIndex])); const initIndex = __pulse_fastly_find(payloadValue, "init"); const init = initIndex >= 0 ? __pulse_fastly_value(unchecked(payloadValue.values[initIndex])) : new __PulseFastlyValue(); let method = "GET"; let body = ""; let headers = new __PulseFastlyValue(); headers.kind = PULSE_VALUE_OBJECT; if (init.kind == PULSE_VALUE_OBJECT) { const methodIndex = __pulse_fastly_find(init, "method"); if (methodIndex >= 0) method = __pulse_fastly_string(unchecked(init.values[methodIndex])).toUpperCase(); const headersIndex = __pulse_fastly_find(init, "headers"); if (headersIndex >= 0) headers = __pulse_fastly_value(unchecked(init.values[headersIndex])); headers = __pulse_fastly_fetch_headers(headers, effectIndex); if (__pulse_fastly_last_error != 0) return; const bodyIndex = __pulse_fastly_find(init, "body"); if (bodyIndex >= 0) { const bodyValue = unchecked(init.values[bodyIndex]); const bodyObject = __pulse_fastly_value(bodyValue); body = bodyObject.kind == PULSE_VALUE_STRING ? bodyObject.text : __pulse_fastly_json(bodyValue, 0) }
     else {
       const jsonIndex = __pulse_fastly_find(init, "json")
       if (jsonIndex >= 0) {
@@ -696,7 +702,7 @@ function host_effect_begin(effectIndex: i32, payload: i32): void { ${needsNative
   const bodyOut = __pulse_fastly_out_i32(); status = fastly_http_body_new(changetype<usize>(bodyOut)); if (status != FASTLY_STATUS_OK) { __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 71, effectIndex); return } const bodyHandle = __pulse_fastly_out_value(bodyOut)
   const methodBytes = __pulse_fastly_utf8(method); status = fastly_http_req_method_set(requestHandle, changetype<usize>(methodBytes), methodBytes.byteLength); if (status != FASTLY_STATUS_OK) { __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 72, effectIndex); return }
   const urlBytes = __pulse_fastly_utf8(url); status = fastly_http_req_uri_set(requestHandle, changetype<usize>(urlBytes), urlBytes.byteLength); if (status != FASTLY_STATUS_OK) { __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 73, effectIndex); return }
-  if (headers.kind == PULSE_VALUE_OBJECT) { for (let i = 0; i < headers.keys.length; i += 1) { const nameBytes = __pulse_fastly_utf8(unchecked(headers.keys[i])); const valueBytes = __pulse_fastly_utf8(__pulse_fastly_string(unchecked(headers.values[i]))); status = fastly_http_req_header_insert(requestHandle, changetype<usize>(nameBytes), nameBytes.byteLength, changetype<usize>(valueBytes), valueBytes.byteLength); if (status != FASTLY_STATUS_OK) { __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 74, effectIndex); return } } }
+  if (headers.kind == PULSE_VALUE_OBJECT) { for (let i = 0; i < headers.keys.length; i += 1) { const nameBytes = __pulse_fastly_utf8(unchecked(headers.keys[i])); const valueBytes = __pulse_fastly_utf8(__pulse_fastly_string(unchecked(headers.values[i]))); status = fastly_http_req_header_append(requestHandle, changetype<usize>(nameBytes), nameBytes.byteLength, changetype<usize>(valueBytes), valueBytes.byteLength); if (status != FASTLY_STATUS_OK) { __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 74, effectIndex); return } } }
   if (body.length > 0) { status = __pulse_fastly_write_body(bodyHandle, body); if (status != FASTLY_STATUS_OK) { __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 75, effectIndex); return } }
   const backend = __pulse_fastly_backend(effectIndex); if (backend.length == 0) { __pulse_fastly_fail(PULSE_ERROR_STATE, 76, effectIndex); return } const backendBytes = __pulse_fastly_utf8(backend); const pendingOut = __pulse_fastly_out_i32(); status = fastly_http_req_send_async(requestHandle, bodyHandle, changetype<usize>(backendBytes), backendBytes.byteLength, changetype<usize>(pendingOut)); if (status != FASTLY_STATUS_OK) { __pulse_fastly_fail(PULSE_ERROR_TRANSPORT, 77, effectIndex); return } unchecked(__pulse_fastly_pending[effectIndex] = __pulse_fastly_out_value(pendingOut)); unchecked(__pulse_fastly_pending_active[effectIndex] = 1); unchecked(__pulse_fastly_payloads[effectIndex] = payload)
 }