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

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-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, 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 ${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;');
+}
+module.exports = {runtimeSource, instrument};