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

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

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

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

@@ -0,0 +1,36 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+function enabled(plan) { return (plan.effects || []).some(effect => effect.kind === 'fetch'); }
+function runtimeSource(plan, accounting) {
+  if (!enabled(plan)) return `function __pulse_fetch_has_deadlines(): bool { return false }
+function __pulse_fetch_request_check(index: i32): bool { return true }
+function __pulse_fetch_request_remaining(): i32 { return 2147483647 }`;
+  return fs.readFileSync(path.join(__dirname,'native-fetch-deadlines.as.ts'),'utf8')
+    .replace('/*ACCOUNTING_CLOCK_STORAGE*/', accounting ? 'const __pulse_fetch_clock_out = new StaticArray<i64>(1)' : '')
+    .replace('/*ACCOUNTING_CLOCK_OUT*/', accounting ? '__pulse_fetch_clock_out' : 'new StaticArray<i64>(1)')
+    .replace('/*ACCOUNTING_CLOCK_FAILURE*/', accounting ? '__fca_clock_failed = true;' : '')
+    .replace('/*ACCOUNTING_REAP*/', accounting ? '__fca_cleanup(); return;' : '')
+    .replace('/*ACCOUNTING_RETIRED*/', accounting ? '' : '__pulse_fetch_retired.push(__pulse_fastly_pending[index]);')
+    .replace('/*ACCOUNTING_UNREAPED*/', accounting?.selection === 'canonical-fetch-cohorts' ? '__fca_unreaped()' : accounting ? '__fetch_ra !== null && __fetch_ra!.bank[2*8+5] != PRL_FREE && __fetch_ra!.bank[2*8+5] != PRL_RESERVED ? 1 : 0' : '__pulse_fetch_retired.length')
+    .replace('/*ACCOUNTING_FORCE_POLL*/', accounting?.selection === 'canonical-fetch-cohorts' ? 'if (__pulse_fetch_active(i)) return true;' : '')
+    .replaceAll('/*ACCOUNTING_POLL*/', accounting ? '__fca_poll' : '__pulse_fetch_poll')
+    .replaceAll('/*ACCOUNTING_LATE_CLOSE*/', accounting ? '__fca_dispose(3); __fca_dispose(4)' : '__pulse_fetch_close_response(response[0]); __pulse_fetch_close_body(body[0])');
+}
+function instrument(input, plan, accounting) {
+  if (!enabled(plan)) return input;
+  let source = input;
+  const replace = (before,after) => {
+    if (!source.includes(before)) throw new Error('Fastly fetch deadline boundary drift: ' + before.slice(0,80));
+    source = source.replace(before,after);
+  };
+  replace('const init = initIndex >= 0 ? __pulse_fastly_value(unchecked(payload.values[initIndex])) : new __PulseFastlyValue(); let method',
+    'const init = initIndex >= 0 ? __pulse_fastly_value(unchecked(payload.values[initIndex])) : new __PulseFastlyValue(); __pulse_fetch_begin_deadline(effectIndex, init); if (__pulse_fastly_last_error != 0) return; let method');
+  replace('const backendBytes = __pulse_fastly_utf8(backend); const pendingOut',
+    `if (!__pulse_fetch_before_send(effectIndex)) { ${accounting ? '__fca_cleanup();' : '__pulse_fetch_close_request(requestHandle); __pulse_fetch_close_body(bodyHandle);'} return; } const backendBytes = __pulse_fastly_utf8(backend); const pendingOut`);
+  replace('function __pulse_fastly_wait_fetch(effectIndex: i32): i32 {',
+    'function __pulse_fastly_wait_fetch(effectIndex: i32): i32 { if (__pulse_fastly_effect_kind(effectIndex) == 1 && (__pulse_fetch_completed[effectIndex] || __pulse_fetch_has_deadlines())) return __pulse_fetch_wait(effectIndex);');
+  replace('function __pulse_invocation_close(): void {', 'function __pulse_invocation_close(): void { __pulse_fetch_reap();');
+  return source;
+}
+module.exports = {runtimeSource,instrument};

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

@@ -0,0 +1,38 @@
+'use strict';
+
+function runtimeSource(dynamic = false) {
+  return `
+@external("fastly_http_req", "close")
+declare function __pulse_fetch_close_request(handle: i32): i32
+@external("fastly_http_body", "close")
+declare function __pulse_fetch_close_body(handle: i32): i32
+function __pulse_fetch_fail(status: i32, stage: i32, effect: i32): void {
+  // Fastly ERROR and HTTP parse/user/incomplete/size/status errors represent
+  // failed exchanges. Invalid arguments, handles and unsupported ABI stay fatal.
+  const network = __pulse_fastly_effect_kind(effect) != 1 || status == 1 || status == 7 || status == 8 || status == 9 || status == 11 || status == 12;
+  if (__pulse_fastly_last_error == 0) __pulse_transport_error = __pulse_transport_slots[effect];
+  __pulse_fastly_fail(network ? PULSE_ERROR_TRANSPORT : PULSE_ERROR_HOSTCALL, stage, effect);
+}
+function __pulse_fetch_failed(): bool {
+  return (__pulse_fastly_last_error == PULSE_ERROR_TRANSPORT || __pulse_fastly_last_error == PULSE_ERROR_HOSTCALL || __pulse_fastly_last_error == PULSE_ERROR_VALUE)
+    && (__pulse_fastly_error_stage == 77 || __pulse_fastly_error_stage == 81 || (__pulse_fastly_error_stage >= 270 && __pulse_fastly_error_stage <= ${dynamic ? 276 : 272}))
+    && __pulse_fastly_effect_kind(__pulse_fastly_error_effect) == 1;
+}
+function __pulse_fetch_send_error(): bool {
+  if (!__pulse_fetch_failed()) return false;
+  const output = new __PulseFastlyValue(); output.kind = PULSE_VALUE_RESPONSE;
+  const network = __pulse_fastly_last_error == PULSE_ERROR_TRANSPORT;
+  output.status = ${dynamic ? '__pulse_fastly_error_stage == 273 ? 400 : ' : ''}__pulse_fastly_error_stage == 270 ? 400 : __pulse_fastly_error_stage == 271 ? 504 : network ? 502 : 500;
+  output.text = ${dynamic ? '__pulse_fastly_error_stage == 273 ? "Unsupported or invalid Native dynamic URL" : __pulse_fastly_error_stage == 274 ? "Dynamic Backends unavailable; enable the Fastly service capability" : __pulse_fastly_error_stage == 275 ? "Dynamic backend registration failed; check service configuration" : __pulse_fastly_error_stage == 276 ? "Dynamic backend registration attempt limit exceeded" : ' : ''}__pulse_fastly_error_stage == 270 ? "Invalid fetch timeoutMs" : __pulse_fastly_error_stage == 271 ? "Gateway Timeout" : network ? "Bad Gateway" : "Internal Server Error";
+  output.headers.push(new __PulseFastlyHeader("content-type", "text/plain; charset=utf-8"));
+  __pulse_fastly_send_result(__pulse_fastly_put(output));
+  return true;
+}
+`;
+}
+function instrument(source, lifecycle) {
+  const marker = `function ${lifecycle?.legacyName('__pulse_fastly_jwt_send_error') || '__pulse_fastly_jwt_send_error'}(): void {`;
+  if (!source.includes(marker)) throw new Error('Fastly fetch error boundary drift.');
+  return source.replace(marker, marker + ' if (__pulse_fetch_send_error()) return;');
+}
+module.exports = {runtimeSource, instrument};

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 };