@pulse-compute/provider-fastly 1.0.0-beta.8 → 1.0.0-beta.9

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-http-effects.js

@@ -519,6 +519,10 @@ class __PulseJsonParser {
 }
 
 const __pulse_fastly_values = new Array<__PulseFastlyValue>()
+// Shared schema admission uses storage-independent lookups. This retained
+// HTTP emitter keeps its existing dense table and lifetime policy.
+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 }
 const __pulse_fastly_pending = new StaticArray<i32>(PULSE_FASTLY_EFFECT_COUNT)
 const __pulse_fastly_pending_active = new StaticArray<i32>(PULSE_FASTLY_EFFECT_COUNT)
 const __pulse_fastly_payloads = new StaticArray<i32>(PULSE_FASTLY_EFFECT_COUNT)

package/src/build/native-platform-capabilities.js

@@ -2,6 +2,7 @@
 
 const { scalarRecordProjectionLines } = require('./schema-scalar-record.js');
 const { hasJsonAdmission, tracksJsonDuplicates, schemaParserDepth, nestedJsonProjectionLines, schemaJsonAdmissionSource, schemaFetchJsonSource } = require('./schema-nested-json.js');
+const { nativeStdioSource } = require('./native-stdio.js');
 const applicationErrors = require('./native-application-errors.js');
 const effectInvocations = require('./effect-invocations.js');
 const packageApplication = require('./package-native-application.js');
@@ -88,6 +89,7 @@ function loadGuestToolchain() {
 
 const { resolveAsc } = loadBuildSupport();
 const { generateCanonicalNativeAssemblyScript } = loadNativeGenerator();
+const nativeHandleOwnership = require('./native-handle-ownership.js');
 const { pulseJwtAssemblyScriptSource } = loadJwtNativeSource();
 const {
   GUEST_LINK_STAGE_INVOCATION_VERSION,
@@ -108,6 +110,7 @@ const FASTLY_NATIVE_PLATFORM_CAPABILITIES_BUFFER_BYTES = 65536;
 const FASTLY_NATIVE_SIZE_OPTIMIZATION = EXPERIMENTAL_NATIVE_SIZE_OPTIMIZATION;
 
 const FASTLY_NATIVE_PLATFORM_CAPABILITIES_IMPORTS = Object.freeze([
+  ...require('./native-body-forwarding.js').IMPORTS.map(key => Object.freeze(key.split(':'))),
   ...conditionalKv.KV_IMPORTS.map((key) => Object.freeze(key.split(':'))),
   ...require('./s3-native.js').S3_IMPORTS.map((key) => Object.freeze(key.split(':'))),
   Object.freeze(['fastly_abi', 'init']),
@@ -143,8 +146,7 @@ const FASTLY_NATIVE_PLATFORM_CAPABILITIES_IMPORTS = Object.freeze([
   Object.freeze(['fastly_kv_store', 'lookup_wait_v2']),
   Object.freeze(['fastly_kv_store', 'insert']),
   Object.freeze(['fastly_kv_store', 'insert_wait']),
-  Object.freeze(['fastly_log', 'endpoint_get']),
-  Object.freeze(['fastly_log', 'write']),
+  Object.freeze(['wasi_snapshot_preview1', 'fd_write']),
   Object.freeze(['wasi_snapshot_preview1', 'clock_time_get'])
 ].filter(([module, name], index, entries) => entries.findIndex((item) => item[0] === module && item[1] === name) === index));
 
@@ -663,6 +665,7 @@ function fastlyGuestLinkedStartWrapperWat() {
 }
 
 function validatePlanBoundary(plan, options = {}) {
+  require('./native-body-forwarding.js').validate(plan, options);
   if (!plan || typeof plan !== 'object') throw new TypeError('Fastly native platform capability realization requires a canonical native plan.');
   if (plan.version !== CANONICAL_NATIVE_PLAN_VERSION) {
     fail(`Fastly native platform capability realization requires ${CANONICAL_NATIVE_PLAN_VERSION}.`, 'PULSE_FASTLY_NATIVE_PLATFORM_CAPABILITIES_PLAN_VERSION_UNSUPPORTED', { version: plan.version });
@@ -930,6 +933,7 @@ function resolveCapabilityBindings(plan, options = {}) {
 
   return Object.freeze({
     maxDurationMs: require('@pulse-compute/runtime/host').normalizeRequestDuration(options.maxDurationMs),
+    bodyForwarding: require('../toolchain/body-forwarding.js').normalizeBodyForwarding(options.bodyForwarding, options.maxDurationMs),
     configStore,
     secretStore,
     s3: require('../toolchain/s3.js').resolveFastlyS3(effects.map((effect) => ({ ...effect, payload: Object.fromEntries(['contentType', 'method', 'range', 'ifNoneMatch'].map(name => [name, literalObjectField(inputExpression(effect, 'payload'), name) ?? undefined])) })), source.s3),
@@ -1009,10 +1013,14 @@ function requiredImportsForPlan(plan, bindings) {
   if (kinds.has('kv.put')) for (const key of ['fastly_kv_store:insert', 'fastly_kv_store:insert_wait']) keys.add(key);
   if (kinds.has('grip.hold')) keys.add('fastly_http_resp:header_append');
   if (plan.logging && plan.logging.enabledStatements > 0) {
-    keys.add('fastly_log:endpoint_get');
-    keys.add('fastly_log:write');
+    keys.add('wasi_snapshot_preview1:fd_write');
   }
   if (kinds.has('s3.head') || kinds.has('s3.getText') || kinds.has('s3.putText') || kinds.has('s3.getBody')) for (const key of require('./s3-native.js').S3_IMPORTS) keys.add(key);
+  if (require('./native-body-forwarding.js').enabled(plan)) {
+    keys.delete('fastly_http_req:send_async'); keys.delete('fastly_http_req:pending_req_wait');
+    for (const key of require('./native-body-forwarding.js').IMPORTS) keys.add(key);
+    keys.add('fastly_http_body:read');
+  }
   return Object.freeze([...keys].sort());
 }
 
@@ -1435,8 +1443,7 @@ function __pulse_fastly_jwt_send_error(): void {}
 @external("fastly_kv_store", "lookup_wait_v2") declare function fastly_kv_store_lookup_wait_v2(handle: i32, bodyOut: usize, metadata: usize, metadataLength: i32, writtenOut: usize, generationOut: usize, kvErrorOut: usize): i32
 @external("fastly_kv_store", "insert") declare function fastly_kv_store_insert(store: i32, key: usize, keyLength: i32, body: i32, configMask: i32, config: usize, insertOut: usize): i32
 @external("fastly_kv_store", "insert_wait") declare function fastly_kv_store_insert_wait(handle: i32, kvErrorOut: usize): i32
-@external("fastly_log", "endpoint_get") declare function fastly_log_endpoint_get(name: usize, nameLength: i32, handleOut: usize): i32
-@external("fastly_log", "write") declare function fastly_log_write(handle: i32, message: usize, messageLength: i32, writtenOut: usize): i32
+${nativeStdioSource}
 @external("wasi_snapshot_preview1", "clock_time_get") declare function wasi_snapshot_preview1_clock_time_get(clockId: i32, precision: i64, timeOut: usize): i32
 
 const PULSE_FASTLY_EFFECTS_ABI_VERSION: i64 = ${FASTLY_NATIVE_PLATFORM_CAPABILITIES_ABI_VERSION}
@@ -1508,6 +1515,7 @@ ${nativeStringFields}
   }
   binaryBody: Uint8Array | null = null
   immutable: bool = false
+${nativeHandleOwnership.fields(options.handleTracing)}
 }
 class __PulseFastlyHeader {
   constructor(public name: string, public value: string) {}
@@ -1640,7 +1648,7 @@ class __PulseJsonParser {
 const PULSE_FASTLY_PENDING_NONE: i32 = 0
 const PULSE_FASTLY_PENDING_ASYNC: i32 = 1
 const PULSE_FASTLY_PENDING_READY: i32 = 2
-@lazy const __pulse_fastly_values = new Array<__PulseFastlyValue>()
+${nativeHandleOwnership.tableSource(options.handleTracing)}
 // Primitive handles have value semantics. Bounded caches keep admitted scalar
 // validation loops from retaining a fresh boxed value for every iteration.
 @lazy const __pulse_fastly_scalar_handles = new StaticArray<i32>(4)
@@ -1664,7 +1672,6 @@ let __pulse_fastly_request_body_loaded: i32 = 0
 let __pulse_fastly_last_error: i32 = 0
 let __pulse_fastly_error_stage: i32 = 0
 let __pulse_fastly_error_effect: i32 = -1
-let __pulse_fastly_log_handle: i32 = -1
 let __pulse_fastly_jwt_error: i32 = 0
 let __pulse_fastly_jwt_secret_calls: i32 = 0
 let __pulse_fastly_jwt_crypto_calls: i32 = 0
@@ -1681,8 +1688,6 @@ function __pulse_fastly_out_i32(): StaticArray<i32> { return new StaticArray<i32
 function __pulse_fastly_out_value(out: StaticArray<i32>): i32 { return load<i32>(changetype<usize>(out)) }
 function __pulse_fastly_utf8(value: string): ArrayBuffer { return String.UTF8.encode(value, false) }
 function __pulse_fastly_decode(buffer: Uint8Array, length: i32): string { return String.UTF8.decodeUnsafe(buffer.dataStart, length, false) }
-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 (handle <= 0 || handle > __pulse_fastly_values.length) { __pulse_fastly_fail(PULSE_ERROR_VALUE, 1, -1); return new __PulseFastlyValue() } return unchecked(__pulse_fastly_values[handle - 1]) }
 ${nativeStringConcat}
 ${nativeStringTrim}
 ${nativeStringIndex}
@@ -1692,7 +1697,7 @@ function __pulse_fastly_string_value(value: string): i32 {
   if (index >= 0) { const cached = unchecked(__pulse_fastly_character_handles[index]); if (cached != 0) return cached }
   const item = new __PulseFastlyValue(); item.kind = PULSE_VALUE_STRING; item.text = value;
   const handle = __pulse_fastly_put(item);
-  if (index >= 0) unchecked(__pulse_fastly_character_handles[index] = handle);
+  if (index >= 0) { unchecked(__pulse_fastly_character_handles[index] = handle); ${options.handleTracing ? 'if (handle != 0) __pulse_handle_cache_roots.push(handle);' : ''} }
   return handle
 }
 function __pulse_fastly_find(object: __PulseFastlyValue, key: string): i32 { for (let i = 0; i < object.keys.length; i += 1) if (unchecked(object.keys[i]) == key) return i; return -1 }
@@ -1723,7 +1728,7 @@ function __pulse_fastly_redact_fields(input: string): string {
   return output + input.substring(start);
 }
 function __pulse_fastly_redact(input: string): string { let output = __pulse_fastly_redact_fields(input); for (let i = 0; i < __pulse_fastly_redactions.length; i += 1) output = __pulse_fastly_replace_secret(output, unchecked(__pulse_fastly_redactions[i])); return output }
-function host_log(level: i32, messageHandle: i32): void { let endpoint = __pulse_fastly_log_handle; if (endpoint == -2) return; if (endpoint == -1) { const name = __pulse_fastly_utf8("stdout"); const out = __pulse_fastly_out_i32(); if (fastly_log_endpoint_get(changetype<usize>(name), name.byteLength, changetype<usize>(out)) != FASTLY_STATUS_OK) { __pulse_fastly_log_handle = -2; return } endpoint = __pulse_fastly_out_value(out); __pulse_fastly_log_handle = endpoint } let label = "unknown"; if (level == 1) label = "error"; else if (level == 2) label = "warn"; else if (level == 3) label = "info"; else if (level == 4) label = "debug"; const bytes = __pulse_fastly_utf8("[pulse:" + label + "] " + __pulse_fastly_redact(__pulse_fastly_string(messageHandle)) + "\n"); const written = __pulse_fastly_out_i32(); fastly_log_write(endpoint, changetype<usize>(bytes), bytes.byteLength, changetype<usize>(written)) }
+function host_log(level: i32, messageHandle: i32): void { let label = "unknown"; if (level == 1) label = "error"; else if (level == 2) label = "warn"; else if (level == 3) label = "info"; else if (level == 4) label = "debug"; const bytes = __pulse_fastly_utf8("[pulse:" + label + "] " + __pulse_fastly_redact(__pulse_fastly_string(messageHandle)) + "\n"); __pulse_fastly_write_stdout(bytes) }
 function __pulse_fastly_number(handle: i32): f64 { const value = __pulse_fastly_value(handle); if (value.kind == PULSE_VALUE_NUMBER) return value.number; if (value.kind == PULSE_VALUE_BOOLEAN) return value.boolean != 0 ? 1.0 : 0.0; if (value.kind == PULSE_VALUE_STRING) return F64.parseFloat(value.text); return 0.0 }
 function __pulse_fastly_hex(value: i32): string { return String.fromCharCode(value < 10 ? 48 + value : 87 + value) }
 function __pulse_fastly_is_unpaired(value: string, i: i32): bool {
@@ -1800,7 +1805,7 @@ function __pulse_fastly_fetch_body(value: __PulseFastlyValue): string { if (valu
 function __pulse_fastly_scalar(kind: i32, boolean: i32, slot: i32): i32 {
   const cached = unchecked(__pulse_fastly_scalar_handles[slot]); if (cached != 0) return cached;
   const item = new __PulseFastlyValue(); item.kind = kind; item.boolean = boolean;
-  const handle = __pulse_fastly_put(item); unchecked(__pulse_fastly_scalar_handles[slot] = handle); return handle
+  const handle = __pulse_fastly_put(item); unchecked(__pulse_fastly_scalar_handles[slot] = handle); ${options.handleTracing ? 'if (handle != 0) __pulse_handle_cache_roots.push(handle);' : ''} return handle
 }
 function host_value_undefined(): i32 { return __pulse_fastly_scalar(PULSE_VALUE_UNDEFINED, 0, 0) }
 function host_value_null(): i32 { return __pulse_fastly_scalar(PULSE_VALUE_NULL, 0, 1) }
@@ -1811,13 +1816,13 @@ function host_value_number(value: f64): i32 {
   const index = cacheable ? i32(value) : -1;
   if (index >= 0) { const cached = unchecked(__pulse_fastly_integer_handles[index]); if (cached != 0) return cached }
   const item = new __PulseFastlyValue(); item.kind = PULSE_VALUE_NUMBER; item.number = value;
-  const handle = __pulse_fastly_put(item); if (index >= 0) unchecked(__pulse_fastly_integer_handles[index] = handle); return handle
+  const handle = __pulse_fastly_put(item); if (index >= 0) { unchecked(__pulse_fastly_integer_handles[index] = handle); ${options.handleTracing ? 'if (handle != 0) __pulse_handle_cache_roots.push(handle);' : ''} } return handle
 }
 function host_value_string(pointer: i32, length: i32): i32 {
   const text = changetype<string>(pointer);
   if (text.length > 1 && text.length <= 128 && __pulse_fastly_literal_handles.has(text)) return __pulse_fastly_literal_handles.get(text);
   const handle = __pulse_fastly_string_value(text);
-  if (text.length > 1 && text.length <= 128 && __pulse_fastly_literal_handles.size < 1024) __pulse_fastly_literal_handles.set(text, handle);
+  if (text.length > 1 && text.length <= 128 && __pulse_fastly_literal_handles.size < 1024) { __pulse_fastly_literal_handles.set(text, handle); ${options.handleTracing ? 'if (handle != 0) __pulse_handle_cache_roots.push(handle);' : ''} }
   return handle
 }
 function host_value_array(): i32 { const item = new __PulseFastlyValue(); item.kind = PULSE_VALUE_ARRAY; return __pulse_fastly_put(item) }
@@ -2055,7 +2060,16 @@ function generateFastlyNativePlatformCapabilitiesAssemblyScript(plan, options =
     );
   }
   const bindings = resolveCapabilityBindings(plan, options);
-  const portable = packageApplication.enabled(plan) ? packageApplication.portable(plan) : generateCanonicalNativeAssemblyScript(plan, options);
+  // Keep final provider eligibility authoritative over the portable artifact
+  // and caller options. Only the selected crypto guest uses the linked policy;
+  // that policy excludes active codecs regardless of JSON arena configuration.
+  const numericRegions = facts.guestUnits.length === 0 ? 'fastly-numeric-regions-v2'
+    : jwtCrypto && jwtCrypto.guestUnitRequired ? 'fastly-linked-numeric-regions-v1' : undefined;
+  const portable = packageApplication.enabled(plan) ? packageApplication.portable(plan) : generateCanonicalNativeAssemblyScript(plan, {
+    ...options, numericRegions,
+    handleOwnership: facts.guestUnits.length === 0 ? 'fastly-handle-tracing-v1' : undefined
+  });
+  nativeHandleOwnership.validateRoots(plan, portable.manifest);
   const portableSource = stripPulseHostImports(portable.source);
   const hasJwt = (plan.effects || []).some((effect) => effect.kind === 'jwt.verify');
   const hasSign = plan.effects.some(effect => effect.kind === 'jwt.sign');
@@ -2066,6 +2080,7 @@ function generateFastlyNativePlatformCapabilitiesAssemblyScript(plan, options =
     '',
     fastlyRuntimeSource(plan, bindings, {
       ...options,
+      handleTracing: portable.manifest.handleOwnership?.enabled === true,
       jwtCrypto,
       es256KeyRecords
     }),
@@ -2082,7 +2097,10 @@ function generateFastlyNativePlatformCapabilitiesAssemblyScript(plan, options =
     require('./native-fetch-deadlines.js').runtimeSource(plan),
     applicationErrors.settlementEnabled(plan) ? applicationErrors.runtimeSource(plan) : '',
     effectInvocations.runtimeSource({ packageCompletion: packageApplication.enabled(plan) }),
+    ...(portable.manifest.numericRegions?.accounting === 'fastly-read-loop-v1' && portable.manifest.numericRegions.regions.length > 0
+      ? [nativeValueBudget.numericRegionSource()] : []),
     portableSource,
+    nativeHandleOwnership.providerSource(plan, portable.manifest.handleOwnership?.enabled === true),
     driverSource(plan, { guestLinked: facts.guestUnits.length > 0 }),
     ''
   ].join('\n');
@@ -2096,6 +2114,7 @@ function generateFastlyNativePlatformCapabilitiesAssemblyScript(plan, options =
   source = effectInvocations.instrument(source);
   source = require('./request-budget.js').instrumentRequestBudget(source, bindings.maxDurationMs, plan);
   source = nativeValueBudget.instrument(source, plan);
+  source = require('./native-body-forwarding.js').instrument(source, plan, bindings);
   const effectKinds = Object.freeze((plan.effects || []).reduce((output, effect) => {
     output[effect.kind] = (output[effect.kind] || 0) + 1;
     return output;
@@ -2119,6 +2138,14 @@ function generateFastlyNativePlatformCapabilitiesAssemblyScript(plan, options =
     portableGeneratorVersion: portable.version,
     portableSourceHash: portable.sourceHash,
     schemaCodecs: portable.manifest.schemaCodecs,
+    ...(portable.manifest.numericRegions ? { numericRegions: portable.manifest.numericRegions } : {}),
+    handleOwnership: portable.manifest.handleOwnership ? Object.freeze({ ...portable.manifest.handleOwnership,
+      providerRoots: portable.manifest.handleOwnership.enabled ? Object.freeze(nativeHandleOwnership.providerRoots(plan)) : Object.freeze([])
+    }) : Object.freeze({
+      policy: null, enabled: false,
+      reason: packageApplication.enabled(plan) ? 'package-owned-emitter' : 'linked-runtime',
+      roots: Object.freeze([]), checkpoints: 'none'
+    }),
     handlerBodies: portable.manifest.handlerBodies,
     ...(portable.manifest.reportOwnership ? { reportOwnership: portable.manifest.reportOwnership } : {}),
     dispatcher: portable.manifest.dispatcher,
@@ -2171,7 +2198,7 @@ function generateFastlyNativePlatformCapabilitiesAssemblyScript(plan, options =
       providerNeutralInput: true,
       javascriptRuntime: false,
       jsComputeRuntime: false,
-      wasi: plan.effects.some(effect => effect.kind === 'fetch') || bindings.maxDurationMs !== undefined || hasJwt || hasSign || bindings.s3.length || plan.effects.some(effect => conditionalKv.KV_CONDITIONAL_KINDS.includes(effect.kind)) ? 'clock_time_get only' : false,
+      wasi: requiredImportsForPlan(plan, bindings).filter(key => key.startsWith('wasi_snapshot_preview1:')).map(key => key.split(':')[1]).join(', ').replace(/(.+)/, '$1 only') || false,
       effects: FASTLY_NATIVE_PLATFORM_EFFECT_KINDS.join(', '),
       continuations: true,
       groupedEffects: 'existing fetch start-before-wait ordering remains intact',
@@ -2183,7 +2210,7 @@ function generateFastlyNativePlatformCapabilitiesAssemblyScript(plan, options =
       kv: 'Fastly KV Store async lookup/insert; conditional operations preserve u64 generations, bounded readiness, strict Pulse envelopes and uncertain dispatch',
       assets: 'Fastly KV Store lookup with provider-owned content type, cache headers, and GET/HEAD body ownership',
       grip: 'canonical stateless framing plus bound, secret-referenced broadcast HTTP realization and stable acknowledgement',
-      logging: 'best-effort redacted writes to the provider-owned stdout logging endpoint',
+      logging: 'best-effort redacted WASI fd_write to stdout (descriptor 1), one attempt per statement',
       schemas: 'fetch JSON decode and structured response encode',
       opaqueResponse: 'origin fetch response/body handles and direct GRIP hold responses pass through without JavaScript runtime ownership',
       transportErrors: 'host status failures remain distinct from HTTP response status',

package/src/build/native-stdio.js

@@ -0,0 +1,20 @@
+'use strict';
+
+// Shared by both Native emitters. Fastly's named logging endpoint ABI rejects
+// stdout/stderr; Compute stdio uses WASI fd_write with stdout descriptor 1.
+const nativeStdioSource = String.raw`
+@external("wasi_snapshot_preview1", "fd_write")
+declare function __pulse_fastly_fd_write(fd: i32, iovs: usize, count: i32, written: usize): i32
+
+function __pulse_fastly_write_stdout(bytes: ArrayBuffer): void {
+  const iov = new StaticArray<usize>(2)
+  unchecked(iov[0] = changetype<usize>(bytes))
+  unchecked(iov[1] = bytes.byteLength)
+  const written = new StaticArray<i32>(1)
+  // One best-effort attempt: errors, zero progress, and short writes never
+  // retry, spin, change the response, or disable subsequent log statements.
+  __pulse_fastly_fd_write(1, changetype<usize>(iov), 1, changetype<usize>(written))
+}
+`;
+
+module.exports = { nativeStdioSource };

package/src/build/native-string-values.js

@@ -1,7 +1,7 @@
 'use strict';
 
-// Host value handles live for the invocation. Store concatenation as shared,
-// immutable prefixes instead of retaining a flat copy for every intermediate.
+// Store concatenation as shared, immutable prefixes instead of retaining a flat
+// copy for every intermediate. Direct object edges preserve live rope children.
 // This changes representation only: coercion happens at the original operation,
 // and aliases keep their original string even after a later append.
 const nativeStringFields = `

package/src/build/native-value-budget.js

@@ -35,6 +35,38 @@ export function pulse_fastly_memory_values(): i64 { return __pulse_memory_values
 `;
 }
 
+// These helpers are private to proven regions in an unlinked read-loop plan.
+// Cache admissions use the original operations, so later boxed code sees the
+// same cache and charges. Uncached numbers pay at each original evaluation;
+// only their physical materialization is delayed until a region exit.
+function numericRegionSource() {
+  return `
+function __pulse_numeric_cacheable(value: f64): bool {
+  return value >= 0 && value < 65536 && Math.floor(value) == value && (value != 0 || 1.0 / value > 0)
+}
+function __pulse_numeric_charge_number(value: f64): f64 {
+  __pulse_memory_charge(0, 0)
+  if (__pulse_numeric_cacheable(value)) host_value_number(value)
+  else __pulse_memory_charge(1, ${policy.valueBytes})
+  return value
+}
+function __pulse_numeric_charge_boolean(value: bool): bool {
+  __pulse_memory_charge(0, 0)
+  host_value_boolean(value ? 1 : 0)
+  return value
+}
+function __pulse_numeric_truthy(value: f64): bool { return value != 0.0 && !isNaN(value) }
+function __pulse_numeric_box(value: f64): i32 {
+  __pulse_memory_charge(0, 0)
+  if (__pulse_numeric_cacheable(value)) return host_value_number(value)
+  const item = new __PulseFastlyValue(); item.kind = PULSE_VALUE_NUMBER; item.number = value
+  // Already charged at the original expression, never a general put bypass.
+  __pulse_fastly_values.push(item)
+  return __pulse_fastly_values.length
+}
+`;
+}
+
 function instrument(source, plan) {
   if (!hasBoundedReadLoop(plan)) return source;
   function insert(needle, extra) {
@@ -55,4 +87,4 @@ function instrument(source, plan) {
   return source + runtimeSource();
 }
 
-module.exports = { policy, hasBoundedReadLoop, runtimeSource, instrument };
+module.exports = { policy, hasBoundedReadLoop, runtimeSource, numericRegionSource, instrument };

package/src/build/schema-admission.js

@@ -10,8 +10,8 @@ class __PulseFastlyAdmissionFrame {
 }
 function __pulse_fastly_admission_enter(handle: i32, budget: __PulseJsonAdmissionBudget,
   stack: Array<__PulseFastlyAdmissionFrame>, active: Set<i32>): bool {
-  if (handle <= 0 || handle > __pulse_fastly_values.length) return budget.fail(12)
-  const value = __pulse_fastly_values[handle - 1]
+  if (!__pulse_fastly_has_value(handle)) return budget.fail(12)
+  const value = __pulse_fastly_value(handle)
   const array = value.kind == PULSE_VALUE_ARRAY
   const object = value.kind == PULSE_VALUE_OBJECT
   if (!budget.node(stack.length + (array || object ? 1 : 0))) return false
@@ -36,7 +36,7 @@ function __pulse_fastly_admit_bounded_value(handle: i32, limits: __PulseJsonAdmi
   if (!__pulse_fastly_admission_enter(handle, budget, stack, active)) return budget
   while (stack.length > 0) {
     const frame = stack[stack.length - 1]
-    const value = __pulse_fastly_values[frame.handle - 1]
+    const value = __pulse_fastly_value(frame.handle)
     if (frame.index == value.values.length) { active.delete(frame.handle); stack.pop(); continue }
     const index = frame.index++
     if (index > 0 && !budget.addBytes(1)) return budget

package/src/config-api.js

@@ -39,6 +39,7 @@ function fastly(options = {}) {
   const normalizedGrip = options.grip === undefined ? undefined : gripBindings(options.grip);
   return Object.freeze({
     kind: 'fastly',
+    ...(options.bodyForwarding === undefined ? {} : {bodyForwarding: require('./toolchain/body-forwarding.js').normalizeBodyForwarding(options.bodyForwarding, options.maxDurationMs)}),
     ...(options.maxDurationMs === undefined ? {} : { maxDurationMs: require('@pulse-compute/runtime/host').normalizeRequestDuration(options.maxDurationMs) }),
     version: FASTLY_PROVIDER_API_VERSION,
     bindings: Object.freeze({

package/src/config-schema.json

@@ -82,6 +82,19 @@
     },
     "fastly.maxWasmBytes": {
       "kind": "positive-safe-integer"
+    },
+    "fastly.bodyForwarding": {
+      "kind": "object"
+    },
+    "fastly.bodyForwarding.requestMaxBytes": {
+      "kind": "integer",
+      "minimum": 1,
+      "maximum": 1048576
+    },
+    "fastly.bodyForwarding.responseMaxBytes": {
+      "kind": "integer",
+      "minimum": 1,
+      "maximum": 1048576
     }
   }
 }

package/src/index.ts

@@ -1,3 +1,4 @@
+const { normalizeBodyForwarding } = require('../src/toolchain/body-forwarding.js') as { normalizeBodyForwarding(value: PulseFastlyBodyForwardingOptions | undefined, maxDurationMs?: number): PulseFastlyBodyForwardingOptions | undefined };
 const { normalizeFastlyMaxWasmBytes } = require('../src/build/wasm-budget.js') as { normalizeFastlyMaxWasmBytes(value?: number): number };
 const { normalizeRequestDuration } = require('@pulse-compute/runtime/host') as { normalizeRequestDuration(value?: number): number | undefined };
 import FASTLY_CONFIG_SCHEMA from './config-schema.json';
@@ -24,10 +25,17 @@ export interface PulseFastlyLocalOptions {
   readonly networkFetch?: boolean;
 }
 
+export interface PulseFastlyBodyForwardingOptions {
+  readonly requestMaxBytes: number;
+  readonly responseMaxBytes: number;
+}
+
 export interface PulseFastlyProviderOptions {
   /** Inclusive final Native Wasm byte budget; default 4 MiB. */
   readonly maxWasmBytes?: number;
   readonly maxDurationMs?: number;
+  /** Experimental Native metered pump; final close hands delivery to Fastly. */
+  readonly bodyForwarding?: PulseFastlyBodyForwardingOptions;
   readonly configStore?: string;
   readonly secretStore?: string;
   readonly kv?: Readonly<Record<string, string>>;
@@ -42,6 +50,8 @@ export interface PulseFastlyProviderOptions {
 
 export interface PulseFastlyProviderConfig {
   readonly maxDurationMs?: number;
+  /** Experimental Native metered pump; final close hands delivery to Fastly. */
+  readonly bodyForwarding?: PulseFastlyBodyForwardingOptions;
   readonly kind: 'fastly';
   readonly version: typeof FASTLY_PROVIDER_API_VERSION;
   readonly bindings: {
@@ -105,6 +115,7 @@ export function fastly(options: PulseFastlyProviderOptions = {}): PulseFastlyPro
   return Object.freeze({
     kind: 'fastly',
     maxDurationMs: normalizeRequestDuration(options.maxDurationMs),
+    bodyForwarding: normalizeBodyForwarding(options.bodyForwarding, options.maxDurationMs),
     version: FASTLY_PROVIDER_API_VERSION,
     bindings: Object.freeze({
       configStore: String(options.configStore ?? fastlyDefaults['fastly.configStore']),

package/src/provider-contract.js

@@ -12,13 +12,14 @@ const FASTLY_PROVIDER_DESCRIPTOR = canonical.normalizeDescriptor({
   deployable: true,
   localExecution: true,
   capabilities: [
-    'request', 'response.json', 'response.text', 'response.custom', 'fetch',
+    'request', 'request.body.forward', 'response.json', 'response.text', 'response.custom', 'fetch',
     'time.wall-clock', 'crypto.digestText', 'config.get', 'secret.get', 'kv.get', 'kv.put', 'kv.getVersioned', 'kv.insertIfAbsent', 'kv.compareAndSwap', 'assets.lookup',
     'grip.channel', 'grip.hold', 'grip.publish', 'grip.broadcast', 'jwt.verify', 'jwt.sign',
     'opaque.pass-through', 's3.head', 's3.getText', 's3.putText', 's3.getBody'
   ],
   lowering: {
     request: 'fastly.compute.request',
+    'request.body.forward': 'fastly.native.body-forwarding',
     'response.json': 'fastly.compute.response.json',
     'response.text': 'fastly.compute.response.text',
     'response.custom': 'fastly.compute.response.custom',
@@ -62,10 +63,12 @@ function validateStaticBackendBindings(metadata = {}, bindings = {}) {
   }
 }
 
-function createFastlyLoweringPlan(metadata, bindings = {}) {
+function createFastlyLoweringPlan(metadata, bindings = {}, options = {}) {
+  const forwarding = require('./toolchain/body-forwarding.js').normalizeBodyForwarding(options.bodyForwarding, options.maxDurationMs);
+  const descriptor = forwarding ? FASTLY_PROVIDER_DESCRIPTOR : {...FASTLY_PROVIDER_DESCRIPTOR, capabilities: FASTLY_PROVIDER_DESCRIPTOR.capabilities.filter(id => id !== 'request.body.forward')};
   require('./toolchain/s3.js').resolveFastlyS3(metadata.providerOperations || [], bindings.s3);
   validateStaticBackendBindings(metadata, bindings);
-  return canonical.createProviderLoweringPlan(metadata, FASTLY_PROVIDER_DESCRIPTOR, {
+  return canonical.createProviderLoweringPlan(metadata, descriptor, {
     ...bindings,
     grip: bindings.grip || 'fastly-fanout'
   });