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

package/src/build/native-dynamic-backends.as.ts

@@ -0,0 +1,115 @@
+// Provider-owned, request-local dynamic backend policy. No optional timeout or
+// trust overrides: deadlines and certificate validation retain their owners.
+@external("fastly_http_req", "register_dynamic_backend")
+declare function __pulse_dynamic_register(name: usize, nameLength: i32, target: usize, targetLength: i32, mask: u32, config: usize): i32
+const __pulse_dynamic_origins = new Array<string>()
+const __pulse_dynamic_names = new Array<string>()
+let __pulse_dynamic_attempts: i32 = 0
+let __pulse_dynamic_status: i32 = 0
+let __pulse_dynamic_url: string = ""
+export function pulse_fastly_dynamic_backend_status(): i32 { return __pulse_dynamic_status }
+function __pulse_dynamic_clear(): void {
+  __pulse_dynamic_origins.length = 0; __pulse_dynamic_names.length = 0; __pulse_dynamic_url = ""
+}
+function __pulse_dynamic_invalid(index: i32): string {
+  __pulse_fastly_fail(PULSE_ERROR_VALUE, 273, index); return ""
+}
+function __pulse_dynamic_select(index: i32, url: string): string {
+  __pulse_dynamic_url = url
+  const fixed = __pulse_fastly_backend(index)
+  if (fixed.length > 0) return fixed
+  if (!__pulse_dynamic_check(index)) return ""
+  if (url.length > PULSE_FASTLY_BUFFER_BYTES) return __pulse_dynamic_invalid(index)
+  for (let i = 0; i < url.length; i++) {
+    const c = url.charCodeAt(i)
+    if (c <= 32 || c >= 127 || c == 92) return __pulse_dynamic_invalid(index)
+  }
+  const separator = url.indexOf("://")
+  if (separator < 0) return __pulse_dynamic_invalid(index)
+  const scheme = url.substring(0, separator).toLowerCase()
+  const tls = scheme == "https"
+  if (!tls && scheme != "http") return __pulse_dynamic_invalid(index)
+  const start = separator + 3
+  let end = start
+  while (end < url.length && url.charAt(end) != "/" && url.charAt(end) != "?" && url.charAt(end) != "#") end++
+  const authority = url.substring(start, end).toLowerCase()
+  if (authority.length == 0 || authority.length > 1024 || authority.indexOf("@") >= 0) return __pulse_dynamic_invalid(index)
+  const colon = authority.indexOf(":")
+  let hostname = colon < 0 ? authority : authority.substring(0, colon)
+  let port = tls ? 443 : 80
+  if (colon >= 0) {
+    const digits = authority.substring(colon + 1)
+    if (digits.length == 0 || digits.length > 5) return __pulse_dynamic_invalid(index)
+    port = 0
+    for (let i = 0; i < digits.length; i++) {
+      const c = digits.charCodeAt(i)
+      if (c < 48 || c > 57) return __pulse_dynamic_invalid(index)
+      port = port * 10 + c - 48
+    }
+    if (port < 1 || port > 65535) return __pulse_dynamic_invalid(index)
+  }
+  const dns = hostname.endsWith(".") ? hostname.substring(0, hostname.length - 1) : hostname
+  if (dns.length == 0 || dns.length > 253) return __pulse_dynamic_invalid(index)
+  const labels = dns.split(".")
+  let allNumeric = true
+  for (let i = 0; i < labels.length; i++) {
+    const label = unchecked(labels[i])
+    if (label.length == 0 || label.length > 63 || label.startsWith("xn--") || label.startsWith("-") || label.endsWith("-")) return __pulse_dynamic_invalid(index)
+    for (let j = 0; j < label.length; j++) {
+      const c = label.charCodeAt(j)
+      if (!((c >= 97 && c <= 122) || (c >= 48 && c <= 57) || c == 45)) return __pulse_dynamic_invalid(index)
+      if (c < 48 || c > 57) allNumeric = false
+    }
+  }
+  if (allNumeric) {
+    if (tls || hostname != dns || labels.length != 4) return __pulse_dynamic_invalid(index)
+    for (let i = 0; i < 4; i++) {
+      const label = unchecked(labels[i])
+      if (label.length > 3 || (label.length > 1 && label.startsWith("0"))) return __pulse_dynamic_invalid(index)
+      let octet = 0
+      for (let j = 0; j < label.length; j++) octet = octet * 10 + label.charCodeAt(j) - 48
+      if (octet > 255) return __pulse_dynamic_invalid(index)
+    }
+  } else {
+    // WHATWG numeric host aliases must not become a different DNS destination.
+    const last = unchecked(labels[labels.length - 1])
+    let numeric = true
+    for (let i = 0; i < last.length; i++) if (last.charCodeAt(i) < 48 || last.charCodeAt(i) > 57) numeric = false
+    if (numeric || last.startsWith("0x")) return __pulse_dynamic_invalid(index)
+  }
+  const host = hostname + (port == (tls ? 443 : 80) ? "" : ":" + port.toString())
+  const origin = scheme + "://" + host
+  let rest = url.substring(end)
+  const fragment = rest.indexOf("#")
+  if (fragment >= 0) rest = rest.substring(0, fragment)
+  if (!rest.startsWith("/")) rest = "/" + rest
+  __pulse_dynamic_url = origin + rest
+  if (__pulse_dynamic_url.length > PULSE_FASTLY_BUFFER_BYTES) return __pulse_dynamic_invalid(index)
+  const mapped = __pulse_dynamic_static(origin)
+  if (mapped.length > 0) return mapped
+  for (let i = 0; i < __pulse_dynamic_origins.length; i++) {
+    if (unchecked(__pulse_dynamic_origins[i]) == origin) return unchecked(__pulse_dynamic_names[i])
+  }
+  if (__pulse_dynamic_attempts >= 32) {
+    __pulse_fastly_fail(PULSE_ERROR_VALUE, 276, index); return ""
+  }
+  const name = "pulse-native-dynamic-" + (__pulse_dynamic_attempts++).toString()
+  const n = __pulse_fastly_utf8(name), target = __pulse_fastly_utf8(hostname + ":" + port.toString())
+  const h = __pulse_fastly_utf8(host), sni = __pulse_fastly_utf8(hostname)
+  const config = new StaticArray<u32>(27)
+  config[0] = <u32>changetype<usize>(h); config[1] = h.byteLength
+  let mask: u32 = 2
+  if (tls) {
+    mask |= 32 | 256 | 2048
+    config[7] = <u32>changetype<usize>(sni); config[8] = sni.byteLength
+    config[13] = <u32>changetype<usize>(sni); config[14] = sni.byteLength
+  }
+  if (!__pulse_dynamic_check(index)) return ""
+  __pulse_dynamic_status = __pulse_dynamic_register(changetype<usize>(n), n.byteLength, changetype<usize>(target), target.byteLength, mask, changetype<usize>(config))
+  if (!__pulse_dynamic_check(index)) return ""
+  if (__pulse_dynamic_status != 0) {
+    __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, __pulse_dynamic_status == 5 ? 274 : 275, index); return ""
+  }
+  __pulse_dynamic_origins.push(origin); __pulse_dynamic_names.push(name)
+  return name
+}

package/src/build/native-dynamic-backends.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const policy = Object.freeze({
+  optIn: 'bindings.dynamicBackends', maxRegistrationAttempts: 32,
+  identity: 'canonical origin with derived Host/TLS policy; request-local',
+  precedence: 'effect backend, configured canonical origin, dynamic registration',
+  urls: 'absolute ASCII HTTP/HTTPS DNS; canonical IPv4 over HTTP; ports 1–65535; no credentials, IDNA or IPv6',
+  tls: 'platform trust; URL DNS hostname for certificate verification and SNI',
+  hostPrerequisite: 'Fastly Dynamic Backends service capability',
+  stages: Object.freeze({ invalidUrl: 273, unavailable: 274, registrationFailed: 275, attemptsExhausted: 276 })
+});
+function active(bindings) { return (Array.isArray(bindings) ? bindings : bindings.backends || []).some(b => b.dynamic === true); }
+function originMappings(origins) {
+  return Object.fromEntries(Object.entries(origins || {}).filter(([, name]) => typeof name === 'string' && name.trim()).map(([origin, name]) => [origin, name.trim()]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+}
+function describe(origins) { return Object.freeze({ ...policy, staticOrigins: Object.freeze(originMappings(origins)) }); }
+function runtimeSource(backends, platform, origins) {
+  if (!active(backends)) return '';
+  const mappings = Object.entries(originMappings(origins));
+  return fs.readFileSync(path.join(__dirname, 'native-dynamic-backends.as.ts'), 'utf8') + '\n'
+    + `function __pulse_dynamic_static(origin: string): string {\n${mappings.map(([origin, name]) => `  if (origin == ${JSON.stringify(origin)}) return ${JSON.stringify(name.trim())}`).join('\n')}\n  return ""\n}\n`
+    + `function __pulse_dynamic_check(index: i32): bool { return ${platform ? '__pulse_fetch_request_check(index) && __pulse_fetch_before_send(index)' : 'true'} }\n`;
+}
+function instrument(source, bindings, platform, origins) {
+  if (!active(bindings)) return source;
+  const replace = (before, after) => {
+    if (!source.includes(before)) throw new Error('Fastly dynamic backend boundary drift: ' + before.slice(0, 100));
+    source = source.replace(before, after);
+  };
+  if (platform) {
+    replace('__pulse_fastly_start_request(effectIndex, url, method, headers, body, __pulse_fastly_backend(effectIndex))',
+      'const backend = __pulse_dynamic_select(effectIndex, url); if (__pulse_fastly_last_error != 0) return; __pulse_fastly_start_request(effectIndex, __pulse_dynamic_url, method, headers, body, backend)');
+  } else {
+    replace('function host_effect_begin(effectIndex: i32, payload: i32): void {',
+      'function host_effect_begin(effectIndex: i32, payload: i32): void { if (__pulse_fastly_last_error != 0) return;');
+    replace('  const requestOut = __pulse_fastly_out_i32(); let status = fastly_http_req_new',
+      '  const backend = __pulse_dynamic_select(effectIndex, url); if (__pulse_fastly_last_error != 0) return;\n  const requestOut = __pulse_fastly_out_i32(); let status = fastly_http_req_new');
+    replace('const urlBytes = __pulse_fastly_utf8(url); status = fastly_http_req_uri_set',
+      'const urlBytes = __pulse_fastly_utf8(__pulse_dynamic_url); status = fastly_http_req_uri_set');
+    replace('const backend = __pulse_fastly_backend(effectIndex); if (backend.length == 0)', 'if (backend.length == 0)');
+  }
+  const entry = source.includes('export function pulse_fastly_handle(): void {') ? 'pulse_fastly_handle' : '_start';
+  replace(`export function ${entry}(): void {`, 'function __pulse_dynamic_start(): void {');
+  return source + '\n' + runtimeSource(bindings, platform, origins) + `\nexport function ${entry}(): void {
+  __pulse_dynamic_clear(); __pulse_dynamic_attempts = 0; __pulse_dynamic_status = 0
+  __pulse_dynamic_start()
+  __pulse_dynamic_clear()
+}\n`;
+}
+module.exports = { active, policy, describe, instrument };

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

@@ -0,0 +1,164 @@
+// 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 __pulse_fetch_retired.length }
+function __pulse_fetch_clock(index: i32): i64 {
+  const out = new StaticArray<i64>(1)
+  if (wasi_snapshot_preview1_clock_time_get(1, 1, changetype<usize>(out)) != 0
+    || out[0] < 0 || out[0] < __pulse_fetch_last_clock) {
+    __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++)
+    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.
+  __pulse_fetch_retired.push(__pulse_fastly_pending[index]); __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 {
+  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 = __pulse_fetch_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) { __pulse_fetch_close_response(response[0]); __pulse_fetch_close_body(body[0]) }
+    __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 = __pulse_fetch_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) {
+          __pulse_fetch_close_response(response[0]); __pulse_fetch_close_body(body[0]); __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,27 @@
+'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) {
+  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');
+}
+function instrument(input, plan) {
+  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)) { __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) {
+  const marker = 'function __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-handle-ownership.js

@@ -0,0 +1,127 @@
+'use strict';
+
+function validateRoots(plan, manifest) {
+  if (!manifest.handleOwnership?.enabled) return;
+  const { CANONICAL_NATIVE_PURE_HELPER_VERSION } = require('@pulse-compute/wasm-contracts/handler/canonical-native-plan');
+  const expected = ['__pulse_result',
+    ...((plan.helpers || []).some(h => h.version !== CANONICAL_NATIVE_PURE_HELPER_VERSION) ? ['__pulse_helper_result'] : []),
+    ...(plan.locals || []).map((_, i) => `__pulse_local_${i}`),
+    ...(plan.effects || []).map((_, i) => `__pulse_effect_result_${i}`),
+    ...(manifest.requestState.enabled ? ['__pulse_state_keys', '__pulse_state_values'] : [])];
+  if (JSON.stringify(manifest.handleOwnership.roots) !== JSON.stringify(expected)) {
+    throw new Error('Fastly handle ownership root descriptor mismatch');
+  }
+}
+
+function providerRoots(plan) {
+  return ['__pulse_request_headers_snapshot', '__pulse_fastly_payloads', '__pulse_fastly_ready',
+    '__pulse_handle_cache_roots', '__pulse_handle_resource_roots',
+    ...((plan.capabilities || []).includes('request.body.forward') ? ['__fwd_marker', '__fwd_result'] : [])];
+}
+
+function providerSource(plan, enabled, roots = providerRoots(plan)) {
+  if (!enabled) return '';
+  if (JSON.stringify(roots) !== JSON.stringify(providerRoots(plan))) throw new Error('Fastly provider root descriptor mismatch');
+  const arrays = new Set(['__pulse_fastly_payloads', '__pulse_fastly_ready', '__pulse_handle_cache_roots', '__pulse_handle_resource_roots']);
+  return ['function __pulse_handle_provider_roots(): void {',
+    ...roots.map(name => arrays.has(name)
+      ? `  for (let i = 0; i < ${name}.length; i++) __pulse_handle_mark(unchecked(${name}[i]))`
+      : `  __pulse_handle_mark(${name})`), '}'].join('\n');
+}
+
+// This source is composed only with the canonical emitter's complete, eligible
+// root descriptor. Synchronous host operations never call the checkpoint.
+function fields(enabled) {
+  return enabled ? `
+  traceHandleEdges(): void {
+    if (this.valuesStorage !== null) {
+      const values = this.valuesStorage!
+      for (let i = 0; i < values.length; i++) {
+        const handle = unchecked(values[i])
+        if (handle <= 0) { __pulse_fastly_fail(PULSE_ERROR_VALUE, 1, -1); return }
+        __pulse_handle_mark(handle)
+      }
+    }
+    if (this.textLeft !== null) __pulse_handle_work!.push(this.textLeft!)
+    if (this.textRight !== null) __pulse_handle_work!.push(this.textRight!)
+  }
+` : '';
+}
+
+function tableSource(enabled) {
+  if (!enabled) return `
+@lazy const __pulse_fastly_values = new Array<__PulseFastlyValue>()
+function __pulse_fastly_has_value(handle: i32): bool { return handle > 0 && handle <= __pulse_fastly_values.length }
+function __pulse_fastly_value_count(): i32 { return __pulse_fastly_values.length }
+function __pulse_fastly_put(value: __PulseFastlyValue): i32 { __pulse_fastly_values.push(value); return __pulse_fastly_values.length }
+function __pulse_fastly_value(handle: i32): __PulseFastlyValue { if (!__pulse_fastly_has_value(handle)) { __pulse_fastly_fail(PULSE_ERROR_VALUE, 1, -1); return new __PulseFastlyValue() } return unchecked(__pulse_fastly_values[handle - 1]) }
+`;
+  return `
+@lazy let __pulse_fastly_values = new Map<i32, __PulseFastlyValue>()
+// The existing caches never evict or replace entries. Record each insertion
+// once so tracing is proportional to occupied slots, not 132,101 possible slots.
+@lazy const __pulse_handle_cache_roots = new Array<i32>()
+// Wrappers keep their existing request lifetime. Resource IDs are never traced
+// as value handles; collection neither closes nor cancels a host resource.
+@lazy const __pulse_handle_resource_roots = new Array<i32>()
+let __pulse_handle_next: i32 = 0
+let __pulse_handle_allocations: i32 = 0
+let __pulse_handle_interval: i32 = 1024
+let __pulse_handle_survivors: Map<i32, __PulseFastlyValue> | null = null
+let __pulse_handle_work: Array<__PulseFastlyValue> | null = null
+function __pulse_fastly_has_value(handle: i32): bool { return handle > 0 && __pulse_fastly_values.has(handle) }
+function __pulse_fastly_value_count(): i32 { return __pulse_fastly_values.size }
+function __pulse_fastly_put(value: __PulseFastlyValue): i32 {
+  // Provider-owned terminal error responses still allocate after a latched
+  // failure, just as on the retained path. Checkpoints remain suppressed.
+  if (__pulse_handle_next == i32.MAX_VALUE) { __pulse_fastly_fail(PULSE_ERROR_VALUE, 1, -1); return 0 }
+  const handle = ++__pulse_handle_next
+  __pulse_fastly_values.set(handle, value)
+  if (value.kind == PULSE_VALUE_FETCH || value.s3Body || value.responseHandle != 0 || value.bodyHandle != 0) __pulse_handle_resource_roots.push(handle)
+  __pulse_handle_allocations++
+  return handle
+}
+function __pulse_fastly_value(handle: i32): __PulseFastlyValue {
+  if (!__pulse_fastly_has_value(handle)) { __pulse_fastly_fail(PULSE_ERROR_VALUE, 1, -1); return new __PulseFastlyValue() }
+  return __pulse_fastly_values.get(handle)
+}
+function __pulse_handle_mark(handle: i32): void {
+  if (handle == 0 || __pulse_fastly_last_error != 0) return
+  const survivors = __pulse_handle_survivors!
+  if (survivors.has(handle)) return
+  if (!__pulse_fastly_has_value(handle)) { __pulse_fastly_fail(PULSE_ERROR_VALUE, 1, -1); return }
+  const value = __pulse_fastly_values.get(handle)
+  survivors.set(handle, value)
+  __pulse_handle_work!.push(value)
+}
+@noinline
+function __pulse_handle_checkpoint(): void {
+  if (__pulse_fastly_last_error != 0 || __pulse_error != 0 || __pulse_handle_allocations < __pulse_handle_interval) return
+  // Separate handle and object visitation: ropes retain direct objects, and
+  // multiple handle IDs can reference one object. Neither permits losing an ID.
+  __pulse_handle_survivors = new Map<i32, __PulseFastlyValue>()
+  __pulse_handle_work = new Array<__PulseFastlyValue>()
+  const visited = new Set<__PulseFastlyValue>()
+  __pulse_handle_guest_roots()
+  __pulse_handle_provider_roots()
+  const work = __pulse_handle_work!
+  while (work.length > 0 && __pulse_fastly_last_error == 0) {
+    const value = work.pop()
+    if (visited.has(value)) continue
+    visited.add(value)
+    value.traceHandleEdges()
+  }
+  // Publish only a complete trace. Rebuilding also drops historical Map
+  // insertion/deletion capacity; no append-only tombstone vector remains.
+  if (__pulse_fastly_last_error == 0) {
+    __pulse_fastly_values = __pulse_handle_survivors!
+    __pulse_handle_interval = max<i32>(1024, __pulse_fastly_values.size)
+    __pulse_handle_allocations = 0
+  }
+  __pulse_handle_survivors = null
+  __pulse_handle_work = null
+}
+`;
+}
+
+module.exports = { fields, tableSource, validateRoots, providerRoots, providerSource };

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

@@ -0,0 +1,50 @@
+'use strict';
+
+function runtimeSource() {
+  return `
+@external("fastly_http_resp", "header_values_get")
+declare function __pulse_response_header_values(handle: i32, name: usize, length: i32, buffer: usize, size: i32, cursor: i32, end: usize, written: usize): i32
+function __pulse_header_lookup_failed(): bool {
+  return __pulse_fastly_last_error == PULSE_ERROR_HOSTCALL && (__pulse_fastly_error_stage == 22 || __pulse_fastly_error_stage == 23);
+}
+function __pulse_header_lookup(handle: i32, name: string, response: bool): string | null {
+  const key = __pulse_fastly_utf8(name), buffer = new Uint8Array(PULSE_FASTLY_BUFFER_BYTES);
+  const end = new StaticArray<i64>(1), written = new StaticArray<i32>(1);
+  written[0] = -1;
+  // The single-value getter reports INVALID_ARGUMENT for absence on Viceroy.
+  // The list ABI distinguishes no values (zero bytes) from an empty value (NUL).
+  const status = response
+    ? __pulse_response_header_values(handle, changetype<usize>(key), key.byteLength, buffer.dataStart, buffer.length, 0, changetype<usize>(end), changetype<usize>(written))
+    : __pulse_request_header_values(handle, changetype<usize>(key), key.byteLength, buffer.dataStart, buffer.length, 0, changetype<usize>(end), changetype<usize>(written));
+  const count = written[0], next = end[0];
+  if (status == FASTLY_STATUS_OK && count == 0 && (next == -1 || next == 0)) return null;
+  if (status != FASTLY_STATUS_OK || count <= 0 || count > buffer.length
+    || (next != -1 && (next <= 0 || next > 4294967295)) || buffer[count - 1] != 0) {
+    __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, response ? 23 : 22, -1); return null;
+  }
+  // Pulse's singular accessor returns the first value, including an empty one.
+  for (let i = 0; i < count; i++) {
+    if (buffer[i] == 0) return String.UTF8.decodeUnsafe(buffer.dataStart, i, false);
+  }
+  __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, response ? 23 : 22, -1); return null;
+}
+function __pulse_header_send_error(): bool {
+  if (!__pulse_header_lookup_failed()) return false;
+  const output = new __PulseFastlyValue(); output.kind = PULSE_VALUE_RESPONSE;
+  output.status = 500; output.text = "Internal Server Error";
+  output.headers.push(new __PulseFastlyHeader("content-type", "text/plain; charset=utf-8"));
+  // Keep the original hostcall stage available to diagnostics.
+  __pulse_fastly_send_result(__pulse_fastly_put(output));
+  return true;
+}
+`;
+}
+function instrument(source) {
+  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 {';
+  if (!source.includes(marker)) throw new Error('Fastly header-lookup error boundary drift.');
+  return source.replace(marker, marker + ' if (__pulse_header_send_error()) return;');
+}
+module.exports = {runtimeSource, instrument};