@pulse-compute/provider-fastly 1.0.0-beta.7 → 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-header-lookup.js

@@ -0,0 +1,54 @@
+'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'};`);
+  // Header reads performed while settling an effect have a separate fatal exit.
+  // Retain its marker so request-budget instrumentation still owns timeout priority.
+  source = source.replace('if (fatal) return',
+    'if (fatal && __pulse_header_lookup_failed()) { __pulse_fastly_jwt_send_error(); return; }\n    if (fatal) return');
+  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};

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)
@@ -880,6 +884,7 @@ function compileFastlyNativeHttpEffectsPlan(plan, options = {}) {
         '--path', jsonAs.dependencyRoot
       );
     }
+    require('@pulse-compute/wasm-build-support/native-optimization').appendJsonCacheArenaArgs(args, options.elideJsonCacheArena, schemaCodecsActive);
     const startedAt = Date.now();
     const result = spawnSync(asc.executable, args, {
       cwd: stagingDir,
@@ -910,7 +915,7 @@ function compileFastlyNativeHttpEffectsPlan(plan, options = {}) {
       compilerVersion: FASTLY_NATIVE_HTTP_EFFECTS_COMPILER_VERSION,
       assemblyScript: Object.freeze({ package: 'assemblyscript', version: require(path.join(asc.packageRoot, 'package.json')).version }),
       jsonAs: jsonAs
-        ? Object.freeze({ package: 'json-as', version: jsonAs.version, transform: true, strict: true, mode: 'NAIVE', fastPath: false })
+        ? Object.freeze({ package: 'json-as', version: jsonAs.version, transform: true, strict: true, mode: 'NAIVE', fastPath: false, elideDisabledCacheArena: options.elideJsonCacheArena === true })
         : undefined,
       wasm: Object.freeze({ bytes: inspection.bytes, sha256: inspection.sha256, magic: inspection.magic }),
       wat: Object.freeze({ bytes: Buffer.byteLength(wat), sha256: sha256(wat) }),