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

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