@pulse-compute/wasm-host-runtime 1.0.0-beta.3 → 1.0.0-beta.5

package/README.md

@@ -7,9 +7,9 @@
 > **Supported entry points:** `None for application authors.`<br>
 > **Stability:** Internal compiler/runtime interface synchronized with this release set.<br>
 > **npm:** [`@pulse-compute/wasm-host-runtime`](https://www.npmjs.com/package/@pulse-compute/wasm-host-runtime)<br>
-> **Canonical documentation:** [Package guide](https://pulsecompute.io/v1.0.0-beta.3/packages/implementation-packages/)
+> **Canonical documentation:** [Package guide](https://pulsecompute.io/v1.0.0-beta.5/packages/implementation-packages/)
 >
-> This release-status block is generated from the synchronized `Pulse 1.0.0-beta.3` package policy.
+> This release-status block is generated from the synchronized `Pulse 1.0.0-beta.5` package policy.
 <!-- pulse-package-status:end -->
 
 Package-owned PulseWasm host-runtime build-time builders and local runtime helpers.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pulse-compute/wasm-host-runtime",
-  "version": "1.0.0-beta.3",
+  "version": "1.0.0-beta.5",
   "license": "Apache-2.0",
   "engines": {
     "node": "^22.14.0 || ^24.0.0"
@@ -28,11 +28,11 @@
     "./runtime/canonical-native-host": "./src/runtime/canonical-native-host.js"
   },
   "dependencies": {
-    "@pulse-compute/crypto": "1.0.0-beta.3",
-    "@pulse-compute/runtime": "1.0.0-beta.3",
-    "@pulse-compute/wasm-build-support": "1.0.0-beta.3",
-    "@pulse-compute/wasm-contracts": "1.0.0-beta.3",
-    "@pulse-compute/wasm-schema-json": "1.0.0-beta.3"
+    "@pulse-compute/crypto": "1.0.0-beta.5",
+    "@pulse-compute/runtime": "1.0.0-beta.5",
+    "@pulse-compute/wasm-build-support": "1.0.0-beta.5",
+    "@pulse-compute/wasm-contracts": "1.0.0-beta.5",
+    "@pulse-compute/wasm-schema-json": "1.0.0-beta.5"
   },
   "publishConfig": {
     "access": "public"
@@ -48,7 +48,7 @@
     "url": "git+https://github.com/pulse-compute/pulse.git",
     "directory": "wasm/packages/host-runtime"
   },
-  "homepage": "https://pulsecompute.io/v1.0.0-beta.3/packages/implementation-packages/",
+  "homepage": "https://pulsecompute.io/v1.0.0-beta.5/packages/implementation-packages/",
   "bugs": {
     "url": "https://github.com/pulse-compute/pulse/issues"
   }

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

@@ -390,6 +390,7 @@ function assertSchemaBodySize(schemaCodecs, text, schemaId, source) {
 const runtimeValueErrorCodes = Object.freeze({
   BodyTooLargeError: 'PULSE_BODY_TOO_LARGE',
   BodyDecodeError: 'PULSE_BODY_DECODE',
+  RequestBodyInvalidUtf8Error: 'PULSE_REQUEST_BODY_INVALID_UTF8',
   BodyUnavailableError: 'PULSE_BODY_UNAVAILABLE',
   OpaqueBodyInspectionError: 'PULSE_OPAQUE_BODY_INSPECTION',
   ResponseEncodeError: 'PULSE_RESPONSE_ENCODE',
@@ -431,7 +432,7 @@ function normalizeRequest(options = {}) {
 function createRequestSurface(request, options = {}, schemaCodecs, trace) {
   const body = runtimeApi.body.createValue(
     { body: request.body, headers: request.headers },
-    { maxBytes: options.maxRequestBodyBytes || options.maxBodyBytes || options.maxStructuredBodyBytes }
+    { maxBytes: options.maxRequestBodyBytes || options.maxBodyBytes || options.maxStructuredBodyBytes, strictUtf8: true }
   );
   const schemaMemo = new Map();
   return Object.freeze({
@@ -634,6 +635,50 @@ function createCanonicalContext(options, trace) {
   }
 
   const ctx = Object.freeze({
+    decodeJson(text, schemaId) {
+      const key = requireSchemaId(schemaCodecs, schemaId, 'application-text');
+      const event = {
+        boundary: 'application-text', schemaId: key, responseCaseId: null,
+        operationId: `application-text:${key}`, status: null,
+        contentType: null, headers: [], bodyOwnership: 'application-owned',
+        target: options.target || null, provider: options.provider || null,
+        effectId: null, groupId: null
+      };
+      try {
+        if (typeof text !== 'string') {
+          throw new CanonicalRuntimeError('SchemaDecodeError', 'PULSE_SCHEMA_DECODE',
+            'Application JSON text must be a string.',
+            { schemaId: key, source: 'application-text', expected: 'string', actualKind: typeof text });
+        }
+        assertSchemaBodySize(schemaCodecs, text, key, 'application-text');
+        const value = schemaCodecs.decodeJsonText(key, text, 'application-text');
+        jsonTrace(trace, { ...event, kind: 'json.decode.text' }, value);
+        return value;
+      } catch (error) {
+        jsonTrace(trace, { ...event, kind: 'json.decode.error', ...jsonTraceErrorDetail(error) });
+        throw error;
+      }
+    },
+    encodeJson(value, schemaId) {
+      const key = requireSchemaId(schemaCodecs, schemaId, 'application-value');
+      const event = {
+        boundary: 'application-value', schemaId: key, responseCaseId: null,
+        operationId: `application-value:${key}`, status: null,
+        contentType: 'application/json; charset=utf-8', headers: [],
+        bodyOwnership: 'application-owned', target: options.target || null,
+        provider: options.provider || null, effectId: null, groupId: null
+      };
+      try {
+        const text = schemaCodecs.encodeJsonText(key, value, 'application-value');
+        assertSchemaBodySize(schemaCodecs, text, key, 'application-value');
+        const normalized = schemaCodecs.decodeJsonText(key, text, 'application-value-trace');
+        jsonTrace(trace, { ...event, kind: 'json.encode.value' }, normalized);
+        return text;
+      } catch (error) {
+        jsonTrace(trace, { ...event, kind: 'json.encode.error', ...jsonTraceErrorDetail(error) });
+        throw error;
+      }
+    },
     req: requestSurface.surface,
     log: Object.freeze(log),
     fetch() {
@@ -891,6 +936,7 @@ function normalizeProviderEffect(effect, schemaCodecs, options = {}) {
   if (effect.kind === 'fetch') return normalizeFetchEffect(effect, schemaCodecs, options);
   const id = String(effect.id || '');
   if (!id) throw new CanonicalRuntimeError('CanonicalEffectProtocolError', 'PULSE_CANONICAL_EFFECT_PROTOCOL', 'Canonical provider effect requires an id.', { effect });
+  if (effect.kind === 'time.now') return Object.freeze({ id, kind: 'time.now', providerKind: 'time', operation: 'now', capability: 'time.wall-clock', source: effect.source, ...(effect.groupKey === undefined ? {} : { groupKey: String(effect.groupKey) }) });
   if (effect.kind === 'config.get' || effect.kind === 'secret.get') {
     return Object.freeze({ id, kind: effect.kind, name: String(effect.name), ...(effect.groupKey === undefined ? {} : { groupKey: String(effect.groupKey) }), source: effect.source });
   }
@@ -1304,6 +1350,16 @@ function createCanonicalHostRuntime(options = {}) {
   const registry = options.continuationRegistry || createContinuationRegistry({ ttlMs: options.continuationTtlMs, clock: options.clock });
 
   async function execute(programModule, executionOptions = {}) {
+    const input = { ...options, ...executionOptions };
+    const budget = portableKv.createRequestBudget(input);
+    try {
+      budget.check();
+      return await executeInvocation(programModule, { ...executionOptions, requestBudget: budget, signal: budget.signal,
+        deadlineMonotonicMs: budget.deadlineMonotonicMs ?? input.deadlineMonotonicMs, kvClock: budget.deadlineMonotonicMs === undefined ? input.kvClock : budget.clock });
+    } finally { if (!input.requestBudget) budget.close(); }
+  }
+
+  async function executeInvocation(programModule, executionOptions) {
     if (!programModule || typeof programModule.createHandler !== 'function') throw new TypeError('Canonical runtime requires a compiled canonical module.');
     const metadata = assertCanonicalProgramCompatibility(programModule);
     executionSequence += 1;
@@ -1365,6 +1421,7 @@ function createCanonicalHostRuntime(options = {}) {
     }
 
     async function dispatchOne(effect) {
+      executionOptions.requestBudget.check();
       const normalized = normalizeProviderEffect(effect, schemaCodecs, runtimeOptions);
       const conditional = portableKv.isConditionalKv(normalized.kind);
       if (conditional) portableKv.registerKvRedactions(normalized, (value) => sensitiveValues.add(value));
@@ -1374,7 +1431,8 @@ function createCanonicalHostRuntime(options = {}) {
         const effectExecution = { ...options, ...executionOptions, metadata, executionId, trace: traceSink, registerRedactionValue: (value) => sensitiveValues.add(value), onKvObservation: recordTrace };
         let snapshot = conditional
           ? await portableKv.executeConditionalKv(normalized, adapter.prepareConditionalKv || ((_admitted, kvExecution) => () => adapter.dispatchEffect(normalized, kvExecution)), effectExecution, runtimeOptions)
-          : await adapter.dispatchEffect(normalized, effectExecution);
+          : await executionOptions.requestBudget.race(adapter.dispatchEffect(normalized, effectExecution));
+        executionOptions.requestBudget.check();
         if (normalized.kind === 'config.get' || normalized.kind === 'secret.get') {
           if (snapshot !== undefined && typeof snapshot !== 'string') {
             throw new CanonicalRuntimeError(
@@ -1395,6 +1453,7 @@ function createCanonicalHostRuntime(options = {}) {
             { receivedType: Array.isArray(snapshot) ? 'array' : snapshot === null ? 'null' : typeof snapshot }
           );
         }
+        if (normalized.kind === 'time.now') snapshot = require('@pulse-compute/runtime/host').normalizeTimeResult(snapshot);
         if (normalized.kind === 'event.emit' && snapshot !== undefined) {
           throw new CanonicalRuntimeError(
             'EventAcceptanceError',
@@ -1467,7 +1526,7 @@ function createCanonicalHostRuntime(options = {}) {
     const generator = programModule.createHandler()(context.ctx, pulse);
     if (!generator || typeof generator.next !== 'function') throw new CanonicalRuntimeError('CanonicalHandlerProtocolError', 'PULSE_CANONICAL_HANDLER_PROTOCOL', 'Compiled canonical handler did not return a generator.');
     let step;
-    try { step = generator.next(); }
+    try { executionOptions.requestBudget.check(); step = generator.next(); }
     catch (error) { error.execution = { executionId, trace: [...trace], continuations: executionContinuations() }; throw error; }
 
     while (!step.done) {
@@ -1481,6 +1540,7 @@ function createCanonicalHostRuntime(options = {}) {
       let value;
       try {
         value = marker.kind === 'group' ? await dispatchGroup(effects) : await dispatchOne(effects[0]);
+        executionOptions.requestBudget.check();
         registry.resume(continuationId);
         recordTrace(Object.freeze({ type: 'continuation-resumed', provider: adapter.id, executionId, continuationId, branchPoint: marker.continuationId }));
         step = generator.next(value);
@@ -1497,7 +1557,7 @@ function createCanonicalHostRuntime(options = {}) {
     }
 
     let response;
-    try { response = finalResponse(step.value, context.request.method); }
+    try { executionOptions.requestBudget.check(); response = finalResponse(step.value, context.request.method); }
     catch (error) {
       error.execution = Object.freeze({ executionId, trace: Object.freeze([...trace]), continuations: Object.freeze(executionContinuations()), resolutionOrder: Object.freeze([...resolutionOrder]) });
       throw error;
@@ -1550,6 +1610,7 @@ module.exports = {
   CanonicalRuntimeError,
   assertCanonicalProgramCompatibility,
   createCanonicalHostRuntime,
+  createRequestBudget: portableKv.createRequestBudget,
   executeCanonicalProgram,
   createCanonicalContext,
   normalizeFetchResponse,

package/src/runtime/canonical-native-host.js

@@ -244,6 +244,7 @@ function nativeEffect(planEffect, payload) {
     resource: planEffect.resource,
     source: planEffect.source
   };
+  if (planEffect.kind === 'time.now') return { ...base, providerKind: 'time', operation: 'now', capability: 'time.wall-clock' };
   if (planEffect.kind === 'fetch') {
     const response = nativeFetchResponseContract(planEffect, payload);
     return { ...base, url: payload.url, init: payload.init, ...response };
@@ -631,6 +632,11 @@ function instantiateCanonicalNativeModule(compiled, options = {}) {
       return put(unary(operator, value(valueHandle)));
     },
     value_truthy(valueHandle) { return value(valueHandle) ? 1 : 0; },
+    value_string_trim(valueHandle) {
+      const input = value(valueHandle);
+      if (typeof input !== 'string') throw new CanonicalNativeHostError('String trim requires a string value.', 'PULSE_CANONICAL_NATIVE_VALUE_TYPE');
+      return put(input.trim());
+    },
     value_nullish(valueHandle) { return value(valueHandle) === null || value(valueHandle) === undefined ? 1 : 0; },
     log(level, messageHandle) {
       const methods = Object.freeze({ 1: 'error', 2: 'warn', 3: 'info', 4: 'debug' });
@@ -645,7 +651,12 @@ function instantiateCanonicalNativeModule(compiled, options = {}) {
     request_url() { requireHttpSurface('ctx.req.url'); return put(context.ctx.req.url); },
     request_path() { requireHttpSurface('ctx.req.path'); return put(context.ctx.req.path); },
     request_headers() { requireHttpSurface('ctx.req.headers'); return put(context.ctx.req.headers); },
-    request_header(nameHandle) { requireHttpSurface('ctx.req.header'); return put(context.ctx.req.header(value(nameHandle))); },
+    request_header(nameHandle) {
+      requireHttpSurface('ctx.req.header');
+      const name = String(value(nameHandle)).toLowerCase();
+      const header = context.ctx.req.headers.find(([key]) => String(key).toLowerCase() === name);
+      return put(header ? header[1] : undefined);
+    },
     request_text() { requireHttpSurface('ctx.req.text'); return put(context.ctx.req.text()); },
     request_json(schemaHandle) {
       requireHttpSurface('ctx.req.json');
@@ -655,6 +666,8 @@ function instantiateCanonicalNativeModule(compiled, options = {}) {
     router_match(pathHandle, patternHandle) { return put(routerMatch(value(pathHandle), value(patternHandle))); },
     router_param(pathHandle, patternHandle, nameHandle) { return put(routerParam(value(pathHandle), value(patternHandle), value(nameHandle))); },
     response_json(valueHandle, optionsHandle) { requireHttpSurface('ctx.json'); return put(context.ctx.json(value(valueHandle), value(optionsHandle))); },
+    schema_encode(valueHandle, schemaHandle) { return put(context.ctx.encodeJson(value(valueHandle), value(schemaHandle))); },
+    schema_decode(textHandle, schemaHandle) { return put(context.ctx.decodeJson(value(textHandle), value(schemaHandle))); },
     response_text(valueHandle, optionsHandle) { requireHttpSurface('ctx.text'); return put(context.ctx.text(value(valueHandle), value(optionsHandle))); },
     response_custom(valueHandle) { requireHttpSurface('ctx.response'); return put(context.ctx.response(value(valueHandle))); },
     grip_is_websocket() {
@@ -747,6 +760,24 @@ function instantiateCanonicalNativeModule(compiled, options = {}) {
     else env[item.name] = () => { throw new CanonicalNativeHostError(`Unsupported AssemblyScript env import ${item.name}.`, 'PULSE_CANONICAL_NATIVE_ENV_IMPORT_UNSUPPORTED', { name: item.name }); };
   }
 
+  let applicationError = 0;
+  const applicationErrors = executionPlane === 'http' && (plan.routing?.entries || []).some(entry => entry.kind === 'error');
+  function captureApplicationError(error) {
+    if (!applicationErrors || options.signal?.aborted || !portableKv.isApplicationError(error)) return false;
+    if (!applicationError) {
+      const safe = canonicalRuntime.redactRuntimeError(error, sensitiveValues);
+      applicationError = put(Object.freeze({ name: safe.name, code: safe.code, message: safe.message }));
+    }
+    return true;
+  }
+  if (applicationErrors) for (const [name, implementation] of Object.entries(pulseHost)) {
+    pulseHost[name] = (...args) => {
+      if (applicationError) return 0;
+      try { return implementation(...args); }
+      catch (error) { if (!captureApplicationError(error)) throw error; return 0; }
+    };
+  }
+  pulseHost.router_error_take = () => { const error = applicationError; applicationError = 0; return error; };
   instance = new WebAssembly.Instance(module, { pulse_host: pulseHost, env });
   if (schemaIndexes.size > 0) {
     const available = new Set(moduleShape.exports.map((entry) => entry.name));
@@ -789,6 +820,7 @@ function instantiateCanonicalNativeModule(compiled, options = {}) {
     }
 
     let result = portableKv.isConditionalKv(effect.kind) ? portableKv.normalizeConditionalKvResult(effect, rawResult, options) : rawResult;
+    if (effect.kind === 'time.now') result = require('@pulse-compute/runtime/host').normalizeTimeResult(rawResult);
     if (effect.kind === 'event.emit' && result !== undefined) {
       throw new canonicalRuntime.CanonicalRuntimeError(
         'EventAcceptanceError',
@@ -896,6 +928,7 @@ function instantiateCanonicalNativeModule(compiled, options = {}) {
     resume() { return instance.exports.pulse_resume(); },
     pendingEffects: takePending,
     prepareEffectResult,
+    captureApplicationError,
     setEffectResult,
     resultValue,
     response() { requireHttpSurface('HTTP completion'); return canonicalRuntime.finalResponse(resultValue(), context.ctx.req.method); },
@@ -914,9 +947,18 @@ function nativeEventCancelled(message) {
   return new CanonicalNativeHostError(message, 'PULSE_CANONICAL_NATIVE_EVENT_CANCELLED');
 }
 
-function raceNativeEventSignal(value, signal) {
+function nativeRequestCancelled(signal) {
+  if (['PULSE_REQUEST_DEADLINE_EXCEEDED', 'PULSE_REQUEST_CLOCK_INVALID'].includes(signal.reason?.code)) return signal.reason;
+  return new portableKv.PulseRuntimeContractError('PULSE_RUNTIME_EFFECT_ABORTED',
+    signal.reason instanceof Error ? signal.reason.message : 'Native execution was cancelled.',
+    { cause: signal.reason });
+}
+
+function raceNativeSignal(value, signal, eventMode = true) {
   if (!signal) return Promise.resolve(value);
-  if (signal.aborted) return Promise.reject(nativeEventCancelled('Native event execution was cancelled during effect dispatch.'));
+  const cancelled = () => eventMode ? nativeEventCancelled('Native event execution was cancelled during effect dispatch.')
+    : nativeRequestCancelled(signal);
+  if (signal.aborted) return Promise.reject(cancelled());
   return new Promise((resolve, reject) => {
     let settled = false;
     const finish = (callback, result) => {
@@ -925,7 +967,7 @@ function raceNativeEventSignal(value, signal) {
       signal.removeEventListener('abort', onAbort);
       callback(result);
     };
-    const onAbort = () => finish(reject, nativeEventCancelled('Native event execution was cancelled during effect dispatch.'));
+    const onAbort = () => finish(reject, cancelled());
     signal.addEventListener('abort', onAbort, { once: true });
     Promise.resolve(value).then(
       (result) => finish(resolve, result),
@@ -954,14 +996,17 @@ async function executeCanonicalNativeInvocation(compiled, options = {}, invocati
   let executionFailure;
   let activeContinuation;
   try {
+    if (!eventMode && options.signal?.aborted) throw nativeRequestCancelled(options.signal);
     if (eventMode && options.signal && options.signal.aborted) {
       throw nativeEventCancelled('Native event execution was cancelled before handler entry.');
     }
+    options.requestBudget?.check();
     status = eventMode ? controller.startEvent(invocation.frame) : controller.start();
     while (status === runtimeContract.CANONICAL_NATIVE_RUN_STATUS.SUSPENDED) {
       if (eventMode && options.signal && options.signal.aborted) {
         throw nativeEventCancelled('Native event execution was cancelled while suspended.');
       }
+      options.requestBudget?.check();
       const pending = controller.pendingEffects();
       if (pending.length !== controller.exports.pulse_pending_count()) {
         throw new CanonicalNativeHostError('Native pending-effect count differs from host queue.', 'PULSE_CANONICAL_NATIVE_PENDING_MISMATCH', { moduleCount: controller.exports.pulse_pending_count(), hostCount: pending.length });
@@ -994,7 +1039,8 @@ async function executeCanonicalNativeInvocation(compiled, options = {}, invocati
       }
       effectCount += pending.length;
 
-      const settled = await Promise.allSettled(pending.map(async (entry) => {
+      const settled = await raceNativeSignal(Promise.allSettled(pending.map(async (entry) => {
+        options.requestBudget?.check();
         if (eventMode && options.signal && options.signal.aborted) {
           throw nativeEventCancelled('Native event execution was cancelled before effect dispatch.');
         }
@@ -1032,19 +1078,27 @@ async function executeCanonicalNativeInvocation(compiled, options = {}, invocati
         const rawResult = conditional
           ? await portableKv.executeConditionalKv(normalized, adapter.prepareConditionalKv || ((_admitted, kvExecution) => () => adapter.dispatchEffect(normalized, kvExecution)),
               { ...effectExecution, onKvObservation: (event) => controller.trace.push(event) }, options)
-          : await raceNativeEventSignal(adapter.dispatchEffect(normalized, effectExecution), eventMode ? options.signal : undefined);
+          : await raceNativeSignal(adapter.dispatchEffect(normalized, effectExecution), options.signal, eventMode);
+        options.requestBudget?.check();
         const result = controller.prepareEffectResult(entry.index, rawResult);
         controller.trace.push(Object.freeze(redactValue({ type: 'native-effect-resolved', executionId, provider: adapter.id, effectId: normalized.id, kind: normalized.kind, result: privateEffect || entry.effect.kind === 'secret.get' ? '<redacted>' : result && typeof result.toJSON === 'function' ? result.toJSON() : result }, controller.sensitiveValues)));
         resolutionOrder.push(entry.effect.id);
         return { entry, result };
-      }));
+      })), options.signal, eventMode);
 
       if (eventMode && options.signal && options.signal.aborted) {
         throw nativeEventCancelled('Native event execution was cancelled while suspended.');
       }
-      const failed = settled.find((entry) => entry.status === 'rejected');
-      if (failed) throw canonicalRuntime.redactRuntimeError(failed.reason, controller.sensitiveValues);
-      for (const item of settled) controller.setEffectResult(item.value.entry.index, item.value.result);
+      options.requestBudget?.check();
+      if (!eventMode && options.signal?.aborted) throw nativeRequestCancelled(options.signal);
+      const failures = settled.filter(entry => entry.status === 'rejected');
+      const failed = failures.find(entry => !portableKv.isApplicationError(entry.reason)) || failures[0];
+      if (failed && (!failures.every(entry => portableKv.isApplicationError(entry.reason))
+        || !controller.captureApplicationError(failed.reason))) {
+        throw canonicalRuntime.redactRuntimeError(failed.reason, controller.sensitiveValues);
+      }
+      settled.forEach((item, index) => controller.setEffectResult(pending[index].index,
+        item.status === 'fulfilled' ? item.value.result : undefined));
       const previousPc = controller.programCounter();
       activeContinuation.state = 'resumed';
       activeContinuation.states.push('resumed');
@@ -1052,8 +1106,8 @@ async function executeCanonicalNativeInvocation(compiled, options = {}, invocati
       if (status === runtimeContract.CANONICAL_NATIVE_RUN_STATUS.INVALID_RESUME) {
         throw new CanonicalNativeHostError('Native module rejected a complete effect-result set.', 'PULSE_CANONICAL_NATIVE_INVALID_RESUME', { programCounter: previousPc, errorCode: controller.lastErrorCode() });
       }
-      activeContinuation.state = 'completed';
-      activeContinuation.states.push('completed');
+      activeContinuation.state = failed ? 'failed' : 'completed';
+      activeContinuation.states.push(activeContinuation.state);
       controller.trace.push(Object.freeze(redactValue({ type: 'native-continuation-resumed', executionId, continuationId: continuation.id, continuationState }, controller.sensitiveValues)));
       activeContinuation = undefined;
     }
@@ -1085,6 +1139,8 @@ async function executeCanonicalNativeInvocation(compiled, options = {}, invocati
         valueHandleCount: controller.heap.size()
       });
     }
+    if (options.signal?.aborted) throw nativeRequestCancelled(options.signal);
+    options.requestBudget?.check();
     const response = controller.response();
     controller.trace.push(Object.freeze(redactValue({ type: 'native-execution-completed', executionId, provider: adapter.id, status: response.status, bodyClass: response.bodyClass }, controller.sensitiveValues)));
     return Object.freeze({
@@ -1125,7 +1181,11 @@ async function executeCanonicalNativeInvocation(compiled, options = {}, invocati
 }
 
 async function executeCanonicalNativeModule(compiled, options = {}) {
-  return executeCanonicalNativeInvocation(compiled, options, Object.freeze({ plane: 'http' }));
+  const budget = portableKv.createRequestBudget(options);
+  try {
+    budget.check();
+    return await executeCanonicalNativeInvocation(compiled, { ...options, requestBudget: budget, signal: budget.signal, deadlineMonotonicMs: budget.deadlineMonotonicMs ?? options.deadlineMonotonicMs, kvClock: budget.deadlineMonotonicMs === undefined ? options.kvClock : budget.clock }, Object.freeze({ plane: 'http' }));
+  } finally { if (!options.requestBudget) budget.close(); }
 }
 
 function nativeEventFailure(error) {