@pulse-compute/provider-fastly 1.0.0-beta.3 → 1.0.0-beta.5

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

@@ -0,0 +1,113 @@
+'use strict';
+
+// Host value handles live for the invocation. Store concatenation as shared,
+// immutable prefixes instead of retaining a flat copy for every intermediate.
+// This changes representation only: coercion happens at the original operation,
+// and aliases keep their original string even after a later append.
+const nativeStringFields = `
+  textLeaf: string = ""
+  textLeft: __PulseFastlyValue | null = null
+  textRight: __PulseFastlyValue | null = null
+  textLength: i32 = 0
+  get text(): string {
+    if (this.textLeft === null) return this.textLeaf
+    const pending = new Array<__PulseFastlyValue>()
+    const parts = new Array<string>()
+    pending.push(this)
+    while (pending.length > 0) {
+      const node = pending.pop()
+      if (node.textLeft === null) parts.push(node.textLeaf)
+      else { pending.push(node.textRight!); pending.push(node.textLeft!) }
+    }
+    this.textLeaf = parts.join("")
+    this.textLeft = null
+    this.textRight = null
+    return this.textLeaf
+  }
+  set text(value: string) {
+    this.textLeaf = value
+    this.textLength = value.length
+    this.textLeft = null
+    this.textRight = null
+  }
+`;
+const nativeStringConcat = `
+function __pulse_fastly_concat(leftHandle: i32, rightHandle: i32): i32 {
+  let left = __pulse_fastly_value(leftHandle)
+  let right = __pulse_fastly_value(rightHandle)
+  // Snapshot non-string coercions now; a referenced object can change later.
+  if (left.kind != PULSE_VALUE_STRING) {
+    leftHandle = __pulse_fastly_string_value(__pulse_fastly_string(leftHandle))
+    left = __pulse_fastly_value(leftHandle)
+  }
+  if (right.kind != PULSE_VALUE_STRING) {
+    rightHandle = __pulse_fastly_string_value(__pulse_fastly_string(rightHandle))
+    right = __pulse_fastly_value(rightHandle)
+  }
+  if (left.textLength == 0) return rightHandle
+  if (right.textLength == 0) return leftHandle
+  const length = i64(left.textLength) + i64(right.textLength)
+  if (length > String.MAX_LENGTH) { __pulse_fastly_fail(PULSE_ERROR_VALUE, 57, -1); return 0 }
+  const value = new __PulseFastlyValue()
+  value.kind = PULSE_VALUE_STRING
+  value.textLength = i32(length)
+  value.textLeft = left
+  value.textRight = right
+  return __pulse_fastly_put(value)
+}
+`;
+
+// ECMAScript WhiteSpace + LineTerminator code units. Keep this explicit rather
+// than inheriting the AssemblyScript library's Unicode whitespace policy.
+const nativeStringTrim = `
+function __pulse_fastly_trim_space(code: i32): bool {
+  return (code >= 9 && code <= 13) || code == 32 || code == 160 || code == 5760
+    || (code >= 8192 && code <= 8202) || code == 8232 || code == 8233
+    || code == 8239 || code == 8287 || code == 12288 || code == 65279
+}
+function host_value_string_trim(handle: i32): i32 {
+  const value = __pulse_fastly_value(handle)
+  if (value.kind != PULSE_VALUE_STRING) { __pulse_fastly_fail(PULSE_ERROR_VALUE, 56, -1); return 0 }
+  let start = 0
+  let end = value.text.length
+  while (start < end && __pulse_fastly_trim_space(value.text.charCodeAt(start))) start += 1
+  while (end > start && __pulse_fastly_trim_space(value.text.charCodeAt(end - 1))) end -= 1
+  return __pulse_fastly_string_value(value.text.substring(start, end))
+}
+`;
+
+// Indexed reads expose one UTF-16 code unit, including an isolated surrogate.
+// Validate property spelling before converting to i32: "01", fractions,
+// negative indices and nonnumeric keys are ordinary missing properties.
+const nativeStringIndex = `
+function __pulse_fastly_string_index(value: __PulseFastlyValue, keyHandle: i32): i32 {
+  const key = __pulse_fastly_value(keyHandle)
+  if (key.kind == PULSE_VALUE_STRING && key.text == "length") return host_value_number(value.textLength)
+  if (key.kind != PULSE_VALUE_NUMBER && key.kind != PULSE_VALUE_STRING) return host_value_undefined()
+  const index = __pulse_fastly_number(keyHandle)
+  if (!(index >= 0 && index < value.textLength)) return host_value_undefined()
+  const position = i32(index)
+  if (index != f64(position)) return host_value_undefined()
+  if (key.kind == PULSE_VALUE_STRING && key.text != position.toString()) return host_value_undefined()
+  let node = value
+  let offset = position
+  while (node.textLeft !== null) {
+    const left = node.textLeft!
+    if (offset < left.textLength) node = left
+    else { offset -= left.textLength; node = node.textRight! }
+  }
+  return __pulse_fastly_string_value(node.textLeaf.charAt(offset))
+}
+`;
+
+function needsNativeValueFailureGuard(plan) {
+  if ((plan.schemas?.references || []).some(entry => ['value-encode', 'text-decode'].includes(entry.usage))) return true;
+  function containsValueOperation(node) {
+    if (!node || typeof node !== 'object') return false;
+    if (node.kind === 'pure-loop' || (node.kind === 'method-call' && node.method === 'string.trim')) return true;
+    return Object.values(node).some(containsValueOperation);
+  }
+  return containsValueOperation(plan.entry?.body) || containsValueOperation(plan.effects);
+}
+
+module.exports = { nativeStringFields, nativeStringConcat, nativeStringTrim, nativeStringIndex, needsNativeValueFailureGuard };

package/src/build/request-budget.as.ts

@@ -0,0 +1,49 @@
+// Provider-owned request lifecycle. No wall time or caller header grants time.
+@external('fastly_async_io', 'select') declare function __request_select(handles: usize, count: i32, timeout: i32, done: usize): i32
+let __request_deadline: i64 = -1;
+let __request_last_clock: i64 = -1;
+let __request_expired: bool = false;
+let __request_error_response: bool = false;
+export function pulse_fastly_request_expired(): i32 { return __request_expired ? 1 : 0; }
+function __request_clock(): i64 {
+  const out = new StaticArray<i64>(1);
+  if (wasi_snapshot_preview1_clock_time_get(1, 1, changetype<usize>(out)) != 0 || out[0] < __request_last_clock) {
+    __request_expired = true;
+    return -1;
+  }
+  __request_last_clock = out[0];
+  return out[0];
+}
+function __request_remaining(): i32 {
+  if (__request_expired) return 0;
+  const now = __request_clock();
+  if (now < 0 || now >= __request_deadline) { __request_expired = true; return 0; }
+  return i32((__request_deadline - now + 999999) / 1000000);
+}
+function __request_check(index: i32 = -1): bool {
+  if (__request_error_response) return true;
+  if (__request_remaining() > 0) return true;
+  __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 260, index);
+  return false;
+}
+function __request_wait(handle: i32, index: i32): bool {
+  const remaining = __request_remaining();
+  if (remaining <= 0) return __request_check(index);
+  const handles = new StaticArray<i32>(1), ready = new StaticArray<i32>(1);
+  handles[0] = handle;
+  const status = __request_select(changetype<usize>(handles), 1, remaining, changetype<usize>(ready));
+  if (status != 0) { __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 261, index); return false; }
+  if (ready[0] == -1) __request_expired = true;
+  return __request_check(index);
+}
+function __request_send_timeout(): void {
+  // A timeout says nothing about remote acceptance of dispatched writes.
+  __request_error_response = true;
+  __pulse_fastly_last_error = 0;
+  const options = host_value_object();
+  host_value_object_set(options, __pulse_fastly_string_value('status'), host_value_number(504.0));
+  const response = host_response_text(__pulse_fastly_string_value('Gateway Timeout'), options);
+  __pulse_fastly_last_error = 0;
+  const status = __pulse_fastly_send_result(response);
+  if (status != 0) __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 262, -1);
+}

package/src/build/request-budget.js

@@ -0,0 +1,43 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const {normalizeRequestDuration} = require('@pulse-compute/runtime/host');
+
+function instrumentRequestBudget(input, duration, plan) {
+  const ms = normalizeRequestDuration(duration);
+  if (ms === undefined) return input;
+  let source = input;
+  const replace = (before, after) => {
+    if (!source.includes(before)) throw new Error('Fastly request budget boundary drift: ' + before.slice(0, 100));
+    source = source.replace(before, after);
+  };
+  replace('  __pulse_fastly_last_error = fastly_abi_init', `  __request_expired = false; __request_error_response = false; __request_last_clock = -1;
+  __request_deadline = __request_clock() + i64(${ms}) * 1000000;
+  __pulse_fastly_last_error = fastly_abi_init`);
+  replace('  const handles = new StaticArray<i32>(2)\n  const downstreamStatus', `  if (!__request_check()) { __request_send_timeout(); return; }
+  const handles = new StaticArray<i32>(2)
+  const downstreamStatus`);
+  replace('function host_effect_begin(effectIndex: i32, payload: i32): void {', 'function host_effect_begin(effectIndex: i32, payload: i32): void {\n  if (!__request_check(effectIndex)) return;');
+  replace('  let runStatus = pulse_start()', '  if (!__request_check()) { __request_send_timeout(); return; }\n  let runStatus = pulse_start()');
+  replace('function __pulse_fastly_resolve_effect(effectIndex: i32): i32 {', `function __pulse_fastly_resolve_effect(effectIndex: i32): i32 {
+  if (!__request_check(effectIndex)) return 0;
+  const kind = __pulse_fastly_effect_kind(effectIndex);
+  if (unchecked(__pulse_fastly_pending_mode[effectIndex]) == PULSE_FASTLY_PENDING_ASYNC && kind != 12 && kind != 13 && kind != 14 && ${plan.effects.filter(e=>e.kind.startsWith('kv.')&&['kv.getVersioned','kv.insertIfAbsent','kv.compareAndSwap'].includes(e.kind)).map(e=>'effectIndex != '+plan.effects.indexOf(e)).join(' && ')||'true'}) {
+    if (!__request_wait(unchecked(__pulse_fastly_pending[effectIndex]), effectIndex)) return 0;
+  }`);
+  replace('    const buffer = new Uint8Array(PULSE_FASTLY_BUFFER_BYTES), read = __pulse_fastly_out_i32();', '    if (!__request_wait(handle, effectIndex)) return "";\n    const buffer = new Uint8Array(PULSE_FASTLY_BUFFER_BYTES), read = __pulse_fastly_out_i32();');
+  replace('while (offset < bytes.byteLength) { const written', 'while (offset < bytes.byteLength) { if (!__request_check()) return 1; const written');
+  replace('function __pulse_fastly_send_result(handle: i32): i32 {', 'function __pulse_fastly_send_result(handle: i32): i32 { if (!__request_check()) return 1;');
+  replace('return fastly_http_resp_send_downstream(responseHandle, bodyHandle, 0)', 'if (!__request_check()) return 1; return fastly_http_resp_send_downstream(responseHandle, bodyHandle, 0)');
+  replace('if (sendStatus != FASTLY_STATUS_OK) __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 104, -1)', 'if (sendStatus != FASTLY_STATUS_OK) { if (__request_expired) { __request_send_timeout(); return; } __pulse_fastly_fail(PULSE_ERROR_HOSTCALL, 104, -1); }');
+  replace('status = fastly_http_req_send_async(requestHandle', 'if (!__request_check(effectIndex)) return; status = fastly_http_req_send_async(requestHandle');
+  replace('function __pulse_fastly_ready_effect(effectIndex: i32, handle: i32): void {', 'function __pulse_fastly_ready_effect(effectIndex: i32, handle: i32): void { if (!__request_check(effectIndex)) return;');
+  source = source.replace('if (fatal) return', 'if (fatal) { if (__request_expired || !__request_check()) __request_send_timeout(); return; }');
+  replace('function __pulse_fastly_jwt_send_error(): void {', 'function __pulse_fastly_jwt_send_error(): void { if (__request_expired || !__request_check()) { __request_send_timeout(); return; }');
+  source = source.replaceAll('runStatus = pulse_resume()', 'if (!__request_check()) { __request_send_timeout(); return; }\n    runStatus = pulse_resume()');
+  replace('  const result = pulse_result_handle()', '  if (!__request_check()) { __request_send_timeout(); return; }\n  const result = pulse_result_handle()');
+  if (source.includes('__kv_deadline[index] = start +')) replace('__kv_deadline[index] = start + i64(__KV_timeoutMs) * 1000000;', '__kv_deadline[index] = min<i64>(__request_deadline, start + i64(__KV_timeoutMs) * 1000000);');
+  if (source.includes('__s3_deadlines[index] = start +')) replace('__s3_deadlines[index] = start + i64(binding.timeout) * 1000000;', '__s3_deadlines[index] = min<i64>(__request_deadline, start + i64(binding.timeout) * 1000000);');
+  return source + '\n' + fs.readFileSync(path.join(__dirname,'request-budget.as.ts'),'utf8');
+}
+module.exports = {instrumentRequestBudget};

package/src/build/s3-native.as.ts

@@ -71,7 +71,9 @@ function __pulse_fastly_s3_begin(index: i32, outer: __PulseFastlyValue): void {
   let data = new Uint8Array(0);
   if (put) {
     const text = __pulse_fastly_value(__pulse_fastly_payload_field(payload, 'text'));
-    if (text.kind != PULSE_VALUE_STRING || !__pulse_s3_scalar(text.text)) { __s3_fail(index, 'invalid-text'); return; }
+    if (text.kind != PULSE_VALUE_STRING) { __s3_fail(index, 'invalid-text'); return; }
+    if (text.text.length > binding.max) { __s3_fail(index, 'too-large'); return; }
+    if (!__pulse_s3_scalar(text.text)) { __s3_fail(index, 'invalid-text'); return; }
     data = __pulse_s3_bytes(text.text);
     if (data.length > binding.max) { __s3_fail(index, 'too-large'); return; }
     __pulse_fastly_remember_secret(text.text);

package/src/build/time-native.js

@@ -0,0 +1,49 @@
+'use strict';
+
+// Provider-owned realtime sampling. The portable guest still suspends through
+// effect_begin; no clock import is exposed to application-authored code.
+function timeNativeSource(plan) {
+  if (!(plan.effects || []).some(effect => effect.kind === 'time.now')) return '';
+  return `
+function __pulse_time_pad(value: i32, width: i32): string {
+  let text = value.toString()
+  while (text.length < width) text = "0" + text
+  return text
+}
+function __pulse_time_iso(ms: u64): string {
+  // Gregorian civil date from whole days since the Unix epoch.
+  const z = <i32>(ms / 86400000) + 719468
+  const era = z / 146097
+  const doe = z - era * 146097
+  const yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365
+  let year = yoe + era * 400
+  const doy = doe - (365 * yoe + yoe / 4 - yoe / 100)
+  const mp = (5 * doy + 2) / 153
+  const day = doy - (153 * mp + 2) / 5 + 1
+  const month = mp + (mp < 10 ? 3 : -9)
+  if (month <= 2) year += 1
+  const rest = <i32>(ms % 86400000)
+  return __pulse_time_pad(year, 4) + "-" + __pulse_time_pad(month, 2) + "-" + __pulse_time_pad(day, 2)
+    + "T" + __pulse_time_pad(rest / 3600000, 2) + ":" + __pulse_time_pad((rest / 60000) % 60, 2)
+    + ":" + __pulse_time_pad((rest / 1000) % 60, 2) + "." + __pulse_time_pad(rest % 1000, 3) + "Z"
+}
+function __pulse_fastly_time_begin(effectIndex: i32, payload: __PulseFastlyValue): void {
+  const out = new StaticArray<u64>(1)
+  const status = wasi_snapshot_preview1_clock_time_get(0, 1000000, changetype<usize>(out))
+  const result = host_value_object()
+  if (status != 0) {
+    host_value_object_set(result, __pulse_fastly_string_value("status"), __pulse_fastly_string_value("failed"))
+    host_value_object_set(result, __pulse_fastly_string_value("reason"), __pulse_fastly_string_value("unavailable"))
+  } else {
+    // Divide integer nanoseconds before conversion to f64 to retain millisecond precision.
+    const ms = unchecked(out[0]) / 1000000
+    host_value_object_set(result, __pulse_fastly_string_value("status"), __pulse_fastly_string_value("ok"))
+    host_value_object_set(result, __pulse_fastly_string_value("unixEpochMs"), host_value_number(<f64>ms))
+    host_value_object_set(result, __pulse_fastly_string_value("iso8601"), __pulse_fastly_string_value(__pulse_time_iso(ms)))
+  }
+  __pulse_fastly_ready_effect(effectIndex, result)
+}
+`;
+}
+
+module.exports = Object.freeze({ timeNativeSource });

package/src/config-api.js

@@ -38,6 +38,7 @@ function fastly(options = {}) {
   const normalizedGrip = options.grip === undefined ? undefined : gripBindings(options.grip);
   return Object.freeze({
     kind: 'fastly',
+    ...(options.maxDurationMs === undefined ? {} : { maxDurationMs: require('@pulse-compute/runtime/host').normalizeRequestDuration(options.maxDurationMs) }),
     version: FASTLY_PROVIDER_API_VERSION,
     bindings: Object.freeze({
       configStore: String(options.configStore ?? fastlyConfigDefault('fastly.configStore')),

package/src/config-schema.json

@@ -72,6 +72,9 @@
     "fastly.local.networkFetch": {
       "kind": "boolean",
       "default": false
+    },
+    "fastly.maxDurationMs": {
+      "kind": "optional-number"
     }
   }
 }

package/src/index.ts

@@ -1,3 +1,4 @@
+const { normalizeRequestDuration } = require('@pulse-compute/runtime/host') as { normalizeRequestDuration(value?: number): number | undefined };
 import FASTLY_CONFIG_SCHEMA from './config-schema.json';
 
 type FastlySchemaRule = Readonly<{ kind: string; default?: unknown }>;
@@ -23,6 +24,7 @@ export interface PulseFastlyLocalOptions {
 }
 
 export interface PulseFastlyProviderOptions {
+  readonly maxDurationMs?: number;
   readonly configStore?: string;
   readonly secretStore?: string;
   readonly kv?: Readonly<Record<string, string>>;
@@ -36,6 +38,7 @@ export interface PulseFastlyProviderOptions {
 }
 
 export interface PulseFastlyProviderConfig {
+  readonly maxDurationMs?: number;
   readonly kind: 'fastly';
   readonly version: typeof FASTLY_PROVIDER_API_VERSION;
   readonly bindings: {
@@ -97,6 +100,7 @@ export function fastly(options: PulseFastlyProviderOptions = {}): PulseFastlyPro
   const normalizedGrip = options.grip === undefined ? undefined : gripBindings(options.grip);
   return Object.freeze({
     kind: 'fastly',
+    maxDurationMs: normalizeRequestDuration(options.maxDurationMs),
     version: FASTLY_PROVIDER_API_VERSION,
     bindings: Object.freeze({
       configStore: String(options.configStore ?? fastlyDefaults['fastly.configStore']),

package/src/javascript/package-effects.js

@@ -15,10 +15,12 @@ function unavailable(effect = {}) {
 function createFastlyJavascriptPackageEffectCapabilities(options = {}) {
   const assetsLookup = options.assetsLookup;
   const gripBroadcast = options.gripBroadcast;
+  const digestText = require('@pulse-compute/crypto/provider').createJavascriptTextDigest(options);
   const jwtVerify = options.jwtVerify;
   return Object.freeze({
     version: FASTLY_JAVASCRIPT_PACKAGE_EFFECTS_VERSION,
     effect(effect, execution) {
+      if (effect && effect.contractId === 'pulse.crypto' && effect.operation === 'digestText') return digestText(effect, execution);
       if (effect && effect.contractId === 'pulse.assets' && effect.operation === 'lookup') {
         if (typeof assetsLookup !== 'function') return unavailable(effect);
         return assetsLookup(effect.payload, execution);
@@ -49,7 +51,8 @@ function withFastlyPackageEffectCapabilities(capabilities, options = {}) {
     ...base,
     effect(effect, execution) {
       if (effect && (
-        effect.contractId === 'pulse.assets'
+        effect.contractId === 'pulse.crypto'
+        || effect.contractId === 'pulse.assets'
         || effect.contractId === 'pulse.grip'
         || effect.contractId === 'pulse.jwt'
       )) {

package/src/javascript/runtime-host.js

@@ -45,10 +45,10 @@ function createFastlyJavascriptCapabilities(options = {}) {
     : undefined;
   return withFastlyPackageEffectCapabilities(
     withFastlyFetchCapability(
-      withFastlyBindingCapabilities(options.capabilities, { ...options, bindingCapabilities }),
+      withFastlyBindingCapabilities({ time: () => runtimeHost.readWallTime(options.wallClock === undefined ? () => Date.now() : options.wallClock), ...options.capabilities }, { ...options, bindingCapabilities }),
       { ...options, fetchImplementation: options.fetchImplementation }
     ),
-    { assetsLookup, gripBroadcast, jwtVerify }
+    { assetsLookup, gripBroadcast, jwtVerify, digestSubtle: options.digestSubtle }
   );
 }
 
@@ -57,6 +57,9 @@ function requestHeaderPairs(request) {
 }
 
 async function executeFastlyJavascriptApplication(application, request, options = {}) {
+  if (options.maxDurationMs !== undefined || options.requestBudget !== undefined) {
+    throw new runtimeHost.PulseRuntimeContractError('PULSE_REQUEST_DURATION_UNSUPPORTED', 'Fastly JavaScript does not implement the request deadline; select Native.');
+  }
   const capabilities = options.effectAdapter === undefined
     ? createFastlyJavascriptCapabilities(options)
     : undefined;

package/src/javascript/target-support-policy.js

@@ -16,6 +16,7 @@ function blockedRestriction(id, restriction) {
 
 function classifyFastlyJavascriptCapability(id, restrictions = {}) {
   const capability = String(id);
+  if (capability === 'crypto.digestText') return decision(capability, 'eligible', 'fastly-javascript-crypto-sha256-runtime-builtin', 'provider-fastly');
   if (['kv.getVersioned', 'kv.insertIfAbsent', 'kv.compareAndSwap'].includes(capability)) return decision(capability, 'blocked', 'fastly-conditional-kv-incomplete', 'provider-fastly');
   if (['s3.head', 's3.getText', 's3.putText'].includes(capability)) return decision(capability, 'blocked', 'fastly-javascript-s3-raw-headers-unavailable', 'provider-fastly');
   if (isJavascriptCoreCapability(capability)) {
@@ -102,6 +103,7 @@ function classifyFastlyJavascriptCapability(id, restrictions = {}) {
 
 function classifyFastlyJavascriptProviderRequirement(id, restrictions = {}) {
   const requirement = String(id);
+  if (requirement === 'crypto.digestText') return decision(requirement, 'eligible', 'fastly-javascript-crypto-sha256-runtime-builtin', 'provider-fastly');
   if (['kv.getVersioned', 'kv.insertIfAbsent', 'kv.compareAndSwap'].includes(requirement)) return decision(requirement, 'blocked', 'fastly-conditional-kv-incomplete', 'provider-fastly');
   if (['s3.head', 's3.getText', 's3.putText'].includes(requirement)) return decision(requirement, 'blocked', 'fastly-javascript-s3-raw-headers-unavailable', 'provider-fastly');
   if (requirement === 'request' || ['response.json', 'response.text', 'response.custom'].includes(requirement)) {
@@ -169,6 +171,11 @@ function restriction(reasonId, configuration) {
 }
 
 function fastlyJavascriptProjectRestrictions(compiled, project) {
+  if (project.providerConfig?.maxDurationMs !== undefined) {
+    const error = new TypeError('fastly.maxDurationMs requires the Native target; Fastly JavaScript does not implement the request deadline.');
+    error.code = 'PULSE_REQUEST_DURATION_UNSUPPORTED';
+    throw error;
+  }
   const bindings = project.providerConfig && project.providerConfig.bindings || {};
   const backends = bindings.backends && typeof bindings.backends === 'object' ? bindings.backends : {};
   const kv = bindings.kv && typeof bindings.kv === 'object' ? bindings.kv : {};

package/src/javascript/target.js

@@ -14,6 +14,11 @@ const FASTLY_JAVASCRIPT_TARGET_DESCRIPTOR = normalizeJavascriptTargetDescriptor(
   crypto: defineCryptoTargetCapabilities({
     target: 'javascript',
     algorithms: [{
+      algorithm: 'SHA-256',
+      realization: 'runtime-builtin',
+      implemented: true,
+      status: 'implemented-d1'
+    }, {
       algorithm: 'HS256',
       realization: 'runtime-builtin',
       implemented: true,
@@ -45,7 +50,7 @@ const FASTLY_JAVASCRIPT_TARGET_DESCRIPTOR = normalizeJavascriptTargetDescriptor(
       kv: true,
       parallel: true
     },
-    packages: ['pulse.assets', 'pulse.grip', 'pulse.jwt'],
+    packages: ['pulse.assets', 'pulse.crypto', 'pulse.grip', 'pulse.jwt'],
     restrictions: {
       fetch: 'origin-backend-map-or-dynamic-opt-in',
       kv: 'logical-store-map-required',

package/src/provider-contract.js

@@ -13,7 +13,7 @@ const FASTLY_PROVIDER_DESCRIPTOR = canonical.normalizeDescriptor({
   localExecution: true,
   capabilities: [
     'request', 'response.json', 'response.text', 'response.custom', 'fetch',
-    'config.get', 'secret.get', 'kv.get', 'kv.put', 'kv.getVersioned', 'kv.insertIfAbsent', 'kv.compareAndSwap', 'assets.lookup',
+    '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',
     'opaque.pass-through', 's3.head', 's3.getText', 's3.putText'
   ],
@@ -23,6 +23,8 @@ const FASTLY_PROVIDER_DESCRIPTOR = canonical.normalizeDescriptor({
     'response.text': 'fastly.compute.response.text',
     'response.custom': 'fastly.compute.response.custom',
     fetch: 'fastly.backend.fetch',
+    'time.wall-clock': 'wasi.clock_time_get.realtime',
+    'crypto.digestText': 'pulse.crypto.guest-source.sha256',
     'config.get': 'fastly.config-store.get',
     'secret.get': 'fastly.secret-store.get',
     'kv.get': 'fastly.kv-store.get',

package/src/runtime/canonical-api-runtime.js

@@ -344,6 +344,8 @@ function createFastlyProviderAdapter(baseOptions = {}) {
     async dispatchEffect(effect, executionOptions = {}) {
       const state = stateFor(executionOptions);
       if (effect.kind === 'fetch') return dispatchFetch(effect, executionOptions);
+      if (effect.kind === 'crypto.digestText') return require('@pulse-compute/crypto/provider').createJavascriptTextDigest(baseOptions)(effect, executionOptions);
+      if (effect.kind === 'time.now') return require('@pulse-compute/runtime/host').readWallTime(baseOptions.wallClock === undefined ? () => Date.now() : baseOptions.wallClock);
       if (effect.kind === 'config.get') return state.surface.config.adapter.get(effect.name);
       if (effect.kind === 'secret.get') {
         const secret = state.surface.secret.adapter.get(effect.name);

package/src/testing/native-platform-capabilities-host.js

@@ -143,7 +143,8 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
   const downstreamRequestHandle = 1;
   const downstreamBodyHandle = 2;
   requests.set(downstreamRequestHandle, { method, url, headers: requestHeaders.map((entry) => [...entry]) });
-  bodies.set(downstreamBodyHandle, { bytes: normalizeBody(requestInput.body), readOffset: 0, writes: [] });
+  bodies.set(downstreamBodyHandle, { bytes: normalizeBody(requestInput.body), readOffset: 0, writes: [],
+    readyAt: monotonicMs + Number(requestInput.readyDelayMs || 0), fixture: requestInput });
   let downstream;
 
   function alloc(kind = 'default') {
@@ -219,6 +220,28 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
     new Uint8Array(memory().buffer, Number(buffer), output.length).set(output);
     return FASTLY_STATUS_OK;
   }
+  function requestHeaderList(values, buffer, size, cursor, end, written, kind) {
+    const limit = Math.min(Number(size), options.requestHeaderPageBytes ?? Number(size));
+    let index = Number(cursor), count = 0;
+    if (index < 0 || index > values.length) return FASTLY_STATUS_ERROR;
+    while (index < values.length) {
+      const bytes = Buffer.from(String(values[index]) + '\0');
+      if (count + bytes.length > limit) {
+        if (count === 0) { writeU32(written, bytes.length); return FASTLY_STATUS_BUFLEN; }
+        break;
+      }
+      new Uint8Array(memory().buffer, Number(buffer) + count, bytes.length).set(bytes);
+      count += bytes.length; index++;
+    }
+    writeU32(written, count);
+    view().setBigInt64(Number(end), index === values.length ? -1n : BigInt(index), true);
+    // Fault injection is host-fixture-only; neither values nor faults enter traces.
+    const fault = options.requestHeaderFault?.({kind, cursor: Number(cursor)});
+    if (fault?.written !== undefined) writeU32(written, fault.written);
+    if (fault?.cursor !== undefined) view().setBigInt64(Number(end), BigInt(fault.cursor), true);
+    if (fault?.unterminated && count) new Uint8Array(memory().buffer)[Number(buffer) + count - 1] = 65;
+    return fault?.status ?? FASTLY_STATUS_OK;
+  }
   const imports = {
     fastly_async_io: {
       select(handles, count, timeout, done) {
@@ -235,6 +258,19 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
     },
     wasi_snapshot_preview1: {
       clock_time_get(clockId, precision, timeOut) {
+        if (Number(clockId) === 1 && typeof options.monotonicClock === 'function') {
+          const sample = options.monotonicClock(monotonicMs);
+          if (sample.status) return sample.status;
+          writeU64(timeOut, sample.nanoseconds);
+          return FASTLY_STATUS_OK;
+        }
+        if (Number(clockId) === 0 && typeof options.realtimeClock === 'function') {
+          const sample = options.realtimeClock();
+          trace.push({ module: 'wasi_snapshot_preview1', name: 'clock_time_get', clockId: 0, precision: String(precision), status: sample.status || 0 });
+          if (sample.status) return sample.status;
+          writeU64(timeOut, sample.nanoseconds);
+          return FASTLY_STATUS_OK;
+        }
         const seconds = Number.isFinite(Number(options.clockUnixSeconds))
           ? Number(options.clockUnixSeconds)
           : Math.floor(Date.now() / 1000);
@@ -304,6 +340,19 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
         trace.push({ module: 'fastly_http_req', name: 'uri_get', handle: Number(handle) });
         return request ? writeUtf8(request.url, buffer, bufferLength, writtenOut) : FASTLY_STATUS_BADF;
       },
+      header_names_get(handle, buffer, size, cursor, end, written) {
+        trace.push({module: 'fastly_http_req', name: 'header_names_get', cursor: Number(cursor)});
+        const request = requests.get(Number(handle));
+        if (!request) return FASTLY_STATUS_BADF;
+        return requestHeaderList([...new Set(request.headers.map(([name]) => name.toLowerCase()))], buffer, size, cursor, end, written, 'names');
+      },
+      header_values_get(handle, pointer, length, buffer, size, cursor, end, written) {
+        trace.push({module: 'fastly_http_req', name: 'header_values_get', cursor: Number(cursor)});
+        const request = requests.get(Number(handle));
+        if (!request) return FASTLY_STATUS_BADF;
+        const name = readUtf8(pointer, length).toLowerCase();
+        return requestHeaderList(request.headers.filter(([key]) => key.toLowerCase() === name).map(([, value]) => value), buffer, size, cursor, end, written, 'values');
+      },
       header_value_get(handle, namePointer, nameLength, valuePointer, valueLength, writtenOut) {
         const request = requests.get(Number(handle));
         const name = readUtf8(namePointer, nameLength);
@@ -603,9 +652,11 @@ function executeFastlyNativePlatformCapabilities(input, options = {}) {
   // Throwing stops the Wasm invocation; it never fabricates an effect result.
   const checkActive = () => { if (options.signal && options.signal.aborted) throw options.signal.reason || new Error('Request cancelled.'); };
   checkActive();
-  if (options.signal) for (const namespace of Object.values(imports)) {
+  if (options.signal || options.hostcallDelayMs) for (const [moduleName, namespace] of Object.entries(imports)) {
     for (const [name, hostcall] of Object.entries(namespace)) if (typeof hostcall === 'function') namespace[name] = (...args) => {
-      checkActive(); const result = hostcall(...args); checkActive(); return result;
+      checkActive(); const result = hostcall(...args);
+      monotonicMs += Number(options.hostcallDelayMs?.[`${moduleName}.${name}`] || 0);
+      checkActive(); return result;
     };
   }
   const module = new WebAssembly.Module(wasm);

package/src/toolchain/config.js

@@ -33,6 +33,7 @@ function normalizeFastlyProviderConfig(value) {
     : {};
   return Object.freeze({
     kind: 'fastly',
+    maxDurationMs: require('@pulse-compute/runtime/host').normalizeRequestDuration(input.maxDurationMs),
     version: input.version ? String(input.version) : undefined,
     bindings: Object.freeze({
       configStore: String(bindings.configStore || 'pulse_config'),
@@ -67,6 +68,7 @@ function fastlyProjectConfigDocument(config) {
   return Object.freeze({
     kind: 'fastly',
     bindings: config.bindings,
+    maxDurationMs: config.maxDurationMs,
     build: config.build,
     local: config.local,
     providerSpecificUserland: false
@@ -100,7 +102,8 @@ const FASTLY_PROJECT_CONFIG_REFERENCE = Object.freeze({
     })
   ]),
   fields: Object.freeze([
-    Object.freeze({ section: 'fastly', path: 'fastly.bindings.s3', type: 'Readonly<Record<string, S3Binding & { backend: string }>>', default: '`{}`', scope: 'Fastly Native S3', description: 'Maps logical names to fixed HTTPS endpoint, bucket, region, named static backend, accessKeyIdSecret, secretAccessKeySecret, optional sessionTokenSecret, maxTextBytes (1–32768, default 32768) and timeoutMs (1–30000, default 10000).', security: 'Credentials resolve through the configured Secret Store at execution. Dynamic backend authority and guest endpoint overrides are forbidden.' }),
+    Object.freeze({section:'fastly',path:'fastly.maxDurationMs',type:'integer',allowed:'1–30000',default:'omitted',scope:'HTTP request execution',description:'One provider-owned monotonic budget through buffered response handoff; expiry attempts 504 before headers commit and never asserts rollback of dispatched writes. No CPU preemption or post-handoff delivery guarantee.'}),
+    Object.freeze({ section: 'fastly', path: 'fastly.bindings.s3', type: 'Readonly<Record<string, S3Binding & { backend: string }>>', default: '`{}`', scope: 'Fastly Native S3', description: 'Maps logical names to fixed HTTPS endpoint, bucket, region, named static backend, accessKeyIdSecret, secretAccessKeySecret, optional sessionTokenSecret, maxTextBytes (1–2097152, default 32768) and timeoutMs (1–30000, default 10000).', security: 'Credentials resolve through the configured Secret Store at execution. Dynamic backend authority and guest endpoint overrides are forbidden.' }),
     Object.freeze({ section: 'fastly', path: 'fastly.configStore', type: 'string', default: '`pulse_config`', scope: 'Fastly config capability', description: 'Fastly Config Store resource name.' }),
     Object.freeze({ section: 'fastly', path: 'fastly.secretStore', type: 'string', default: '`pulse_secrets`', scope: 'Fastly secret capability', description: 'Fastly Secret Store resource name.', security: 'The name is build metadata; secret values are never embedded by this option.' }),
     Object.freeze({ section: 'fastly', path: 'fastly.kv', type: 'Readonly<Record<string, string>>', default: '`{}`', scope: 'Fastly KV capability', description: 'Maps logical ctx.kv names to Fastly KV Store resource names.', diagnostics: Object.freeze(['PULSE_FASTLY_KV_BINDINGS_INVALID']) }),

package/src/toolchain/index.js

@@ -332,7 +332,7 @@ function createDriver() {
       });
     },
     executionOptions(providerConfig = {}, values = {}) {
-      return { ...values, bindings: providerConfig.bindings };
+      return { ...values, maxDurationMs: providerConfig.maxDurationMs, bindings: providerConfig.bindings };
     }
   });
 }