@pulse-compute/provider-node 1.0.0-beta.4 → 1.0.0-beta.5

package/README.md

@@ -8,9 +8,9 @@
 > **Stability:** The listed built-in toolchain entry is synchronized with the Beta bootstrap contract; other canonical Node provider interfaces remain internal.<br>
 > **npm:** [`@pulse-compute/provider-node`](https://www.npmjs.com/package/@pulse-compute/provider-node)<br>
 > **Canonical replacement:** `provider: 'node' through @pulse-compute/cli`<br>
-> **Canonical documentation:** [Package guide](https://pulsecompute.io/v1.0.0-beta.4/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.4` package policy.
+> This release-status block is generated from the synchronized `Pulse 1.0.0-beta.5` package policy.
 <!-- pulse-package-status:end -->
 
 Canonical Node provider implementation used internally when a project selects `provider: 'node'`.
@@ -60,4 +60,4 @@ The package exposes focused compiler and runtime modules for the synchronized
 repository, including `runtime/canonical-api-runtime`. Those exports are
 implementation interfaces, not application-author APIs.
 
-See [Contracts and providers](https://pulsecompute.io/v1.0.0-beta.4/concepts/contracts-and-providers/) and [Implementation packages](https://pulsecompute.io/v1.0.0-beta.4/packages/implementation-packages/).
+See [Contracts and providers](https://pulsecompute.io/v1.0.0-beta.5/concepts/contracts-and-providers/) and [Implementation packages](https://pulsecompute.io/v1.0.0-beta.5/packages/implementation-packages/).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pulse-compute/provider-node",
-  "version": "1.0.0-beta.4",
+  "version": "1.0.0-beta.5",
   "license": "Apache-2.0",
   "engines": {
     "node": "^22.14.0 || ^24.0.0"
@@ -42,13 +42,13 @@
     "./javascript/source-package": "./src/javascript/source-package.js"
   },
   "dependencies": {
-    "@pulse-compute/crypto": "1.0.0-beta.4",
-    "@pulse-compute/jwt": "1.0.0-beta.4",
-    "@pulse-compute/runtime": "1.0.0-beta.4",
-    "@pulse-compute/s3": "1.0.0-beta.4",
-    "@pulse-compute/wasm-build-support": "1.0.0-beta.4",
-    "@pulse-compute/wasm-contracts": "1.0.0-beta.4",
-    "@pulse-compute/wasm-host-runtime": "1.0.0-beta.4"
+    "@pulse-compute/crypto": "1.0.0-beta.5",
+    "@pulse-compute/jwt": "1.0.0-beta.5",
+    "@pulse-compute/runtime": "1.0.0-beta.5",
+    "@pulse-compute/s3": "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-host-runtime": "1.0.0-beta.5"
   },
   "publishConfig": {
     "access": "public"
@@ -64,7 +64,7 @@
     "url": "git+https://github.com/pulse-compute/pulse.git",
     "directory": "packages/provider-node"
   },
-  "homepage": "https://pulsecompute.io/v1.0.0-beta.4/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/capabilities.js

@@ -9,6 +9,8 @@ const NODE_CANONICAL_PROVIDER_CAPABILITIES = Object.freeze([
   'response.text',
   'response.custom',
   'fetch',
+  'time.wall-clock',
+  'crypto.digestText',
   'config.get',
   'secret.get',
   'kv.get',
@@ -28,6 +30,8 @@ const NODE_CANONICAL_PROVIDER_LOWERING = Object.freeze({
   'response.text': 'node.http.response.text',
   'response.custom': 'node.http.response.custom',
   fetch: 'node.fetch.dispatch',
+  'time.wall-clock': 'node.runtime.time.now',
+  'crypto.digestText': 'node.crypto.digest-text',
   'config.get': 'node.runtime.config.get',
   'secret.get': 'node.runtime.secret.get',
   'kv.get': 'node.runtime.kv.get',
@@ -54,7 +58,8 @@ const NODE_NATIVE_TARGET_CAPABILITIES = Object.freeze([
   'secret.get',
   'event.ingress',
   'event.emit',
-  'time.wall-clock'
+  'time.wall-clock',
+  'crypto.digestText'
 ]);
 
 module.exports = Object.freeze({

package/src/javascript/fetch-adapter.js

@@ -29,6 +29,10 @@ function createNodeJavascriptFetchCapability(options = {}) {
         signal: execution.signal,
         redirect: 'follow'
       });
+      if (execution.signal?.aborted) {
+        if (response instanceof Response && response.body) void response.body.cancel(execution.signal.reason).catch(() => {});
+        throw execution.signal.reason;
+      }
       if (!(response instanceof Response) && !runtimeHost.isPulseFetchResponse(response)) {
         throw fetchError(
           'PULSE_FETCH_RESPONSE_INVALID',

package/src/javascript/lifecycle.js

@@ -6,6 +6,7 @@ const { createNodeJavascriptHandler } = require('./node-adapter.js');
 const NODE_JAVASCRIPT_LIFECYCLE_VERSION = 'pulse.node-javascript-lifecycle.v1';
 
 function statusForError(error) {
+  if (['PULSE_REQUEST_DEADLINE_EXCEEDED', 'PULSE_REQUEST_CLOCK_INVALID'].includes(error?.code)) return 504;
   if (error && error.code === 'PULSE_REQUEST_BODY_TOO_LARGE') return 413;
   if (error && error.code === 'PULSE_NODE_REQUEST_READ_FAILED') return 400;
   return 500;
@@ -18,7 +19,8 @@ function writeSafeError(response, error) {
   }
   response.statusCode = statusForError(error);
   response.setHeader('content-type', 'text/plain; charset=utf-8');
-  response.end(response.statusCode === 413 ? 'Payload Too Large' : (response.statusCode === 400 ? 'Bad Request' : 'Internal Server Error'));
+  if (response.statusCode === 504) response.setHeader('connection', 'close');
+  response.end(response.statusCode === 504 ? 'Gateway Timeout' : response.statusCode === 413 ? 'Payload Too Large' : (response.statusCode === 400 ? 'Bad Request' : 'Internal Server Error'));
 }
 
 function createNodeJavascriptServer(application, options = {}) {

package/src/javascript/node-adapter.js

@@ -67,33 +67,31 @@ function bodyAllowed(method) {
   return normalized !== 'GET' && normalized !== 'HEAD';
 }
 
-async function readNodeRequestBody(request, maxBytes = DEFAULT_MAX_BODY_BYTES) {
+async function readNodeRequestBody(request, maxBytes = DEFAULT_MAX_BODY_BYTES, signal) {
   const limit = Number(maxBytes);
   if (!Number.isSafeInteger(limit) || limit <= 0) throw new TypeError('Pulse Node maxBodyBytes must be a positive safe integer.');
-  const chunks = [];
-  let bytes = 0;
-  try {
-    for await (const chunk of request) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let bytes = 0;
+    function cleanup() {
+      for (const [event, fn] of [['data', data], ['end', end], ['error', error], ['aborted', aborted]]) request.removeListener(event, fn);
+      signal?.removeEventListener('abort', cancel);
+    }
+    function fail(cause) { cleanup(); chunks.length = 0; request.once('error', () => {}); request.resume(); reject(cause); }
+    function cancel() { fail(signal.reason); }
+    function error(cause) { fail(new PulseNodeJavascriptRequestError('PULSE_NODE_REQUEST_READ_FAILED', 'Pulse could not read the Node request body.', { causeName: cause?.name })); }
+    function aborted() { error(new Error('Request aborted')); }
+    function data(chunk) {
       const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
       bytes += buffer.byteLength;
-      if (bytes > limit) {
-        throw new PulseNodeJavascriptRequestError(
-          'PULSE_REQUEST_BODY_TOO_LARGE',
-          `Request body exceeds ${limit} bytes.`,
-          { maxBytes: limit, bytes }
-        );
-      }
+      if (bytes > limit) return fail(new PulseNodeJavascriptRequestError('PULSE_REQUEST_BODY_TOO_LARGE', `Request body exceeds ${limit} bytes.`, { maxBytes: limit, bytes }));
       chunks.push(buffer);
     }
-  } catch (error) {
-    if (error instanceof PulseNodeJavascriptRequestError) throw error;
-    throw new PulseNodeJavascriptRequestError(
-      'PULSE_NODE_REQUEST_READ_FAILED',
-      'Pulse could not read the Node request body.',
-      { causeName: error && error.name }
-    );
-  }
-  return Buffer.concat(chunks);
+    function end() { cleanup(); resolve(Buffer.concat(chunks)); }
+    if (signal?.aborted) return cancel();
+    signal?.addEventListener('abort', cancel, { once: true });
+    request.on('data', data); request.once('end', end); request.once('error', error); request.once('aborted', aborted);
+  });
 }
 
 async function nodeRequestToWebRequest(request, options = {}) {
@@ -104,7 +102,7 @@ async function nodeRequestToWebRequest(request, options = {}) {
   for (const [name, value] of headerPairs) headers.append(name, value);
   const init = { method, headers };
   if (bodyAllowed(method)) {
-    const body = await readNodeRequestBody(request, options.maxRequestBodyBytes ?? options.maxBodyBytes);
+    const body = await readNodeRequestBody(request, options.maxRequestBodyBytes ?? options.maxBodyBytes, options.signal);
     if (body.byteLength > 0) {
       init.body = body;
       init.duplex = 'half';
@@ -144,25 +142,39 @@ async function writeWebResponseToNode(response, nodeResponse, options = {}) {
   if (!(response instanceof Response)) throw new TypeError('Pulse Node response adaptation requires a Web Response.');
   if (!nodeResponse || typeof nodeResponse.end !== 'function') throw new TypeError('Pulse Node response adaptation requires a ServerResponse-like object.');
 
-  nodeResponse.statusCode = response.status;
-  if (response.statusText && typeof nodeResponse.statusMessage === 'string') nodeResponse.statusMessage = response.statusText;
-  for (const group of groupHeaderPairs(runtimeHost.responseHeaderPairs(response))) {
-    nodeResponse.setHeader(group.name, group.values.length === 1 ? group.values[0] : [...group.values]);
-  }
+  const check = () => { options.requestBudget?.check(); options.signal?.throwIfAborted(); };
+  try {
+    check();
+    nodeResponse.statusCode = response.status;
+    if (response.statusText && typeof nodeResponse.statusMessage === 'string') nodeResponse.statusMessage = response.statusText;
+    for (const group of groupHeaderPairs(runtimeHost.responseHeaderPairs(response))) {
+      nodeResponse.setHeader(group.name, group.values.length === 1 ? group.values[0] : [...group.values]);
+    }
 
-  const method = String(options.requestMethod || 'GET').toUpperCase();
-  if (method === 'HEAD' || !statusAllowsBody(response.status) || response.body == null) {
-    nodeResponse.end();
-    return response;
-  }
+    const method = String(options.requestMethod || 'GET').toUpperCase();
+    if (method === 'HEAD' || !statusAllowsBody(response.status) || response.body == null) {
+      check();
+      nodeResponse.end();
+      return response;
+    }
+
+    if (typeof Readable.fromWeb === 'function') {
+      check();
+      await pipeline(Readable.fromWeb(response.body), nodeResponse, { signal: options.signal });
+      check();
+      return response;
+    }
 
-  if (typeof Readable.fromWeb === 'function') {
-    await pipeline(Readable.fromWeb(response.body), nodeResponse);
+    const body = Buffer.from(await response.arrayBuffer());
+    check();
+    nodeResponse.end(body);
     return response;
+  } catch (error) {
+    if (response.body && !response.body.locked) void response.body.cancel(error).catch(() => {});
+    // Preserve the deadline diagnostic instead of pipeline's generic AbortError.
+    check();
+    throw error;
   }
-
-  nodeResponse.end(Buffer.from(await response.arrayBuffer()));
-  return response;
 }
 
 async function resolveRequestOption(value, context) {
@@ -189,85 +201,92 @@ function createNodeJavascriptHandler(application, options = {}) {
         maxKvValueEntries: options.maxKvValueEntries
       });
   return async function pulseNodeJavascriptHandler(request, response) {
-    const adapted = await nodeRequestToWebRequest(request, options);
-    const requestContext = Object.freeze({
-      request,
-      response,
-      webRequest: adapted.request,
-      headerPairs: adapted.headerPairs
-    });
-    const requestedCapabilities = await resolveRequestOption(options.capabilities, requestContext);
-    const effectAdapter = await resolveRequestOption(options.effectAdapter, requestContext);
-    const schemaCodecs = await resolveRequestOption(options.schemaCodecs, requestContext);
-    const config = hasDynamicBindings ? await resolveRequestOption(options.config, requestContext) : options.config;
-    const secrets = hasDynamicBindings ? await resolveRequestOption(options.secrets, requestContext) : options.secrets;
-    const kv = hasDynamicBindings ? await resolveRequestOption(options.kv, requestContext) : options.kv;
-    const bindings = staticBindings || createNodeJavascriptBindingCapabilities({
-      config, secrets, kv,
-      kvReference: options.kvReference,
-      maxBindingNameBytes: options.maxBindingNameBytes,
-      maxBindingValueBytes: options.maxBindingValueBytes,
-      maxKvNamespaceBytes: options.maxKvNamespaceBytes,
-      maxKvKeyBytes: options.maxKvKeyBytes,
-      maxKvValueBytes: options.maxKvValueBytes,
-      maxKvValueDepth: options.maxKvValueDepth,
-      maxKvValueEntries: options.maxKvValueEntries
-    });
-    const capabilities = effectAdapter === undefined
-      ? withNodeBindingCapabilities(requestedCapabilities, { bindings })
-      : requestedCapabilities;
-    const started = process.hrtime.bigint();
-    const activeApplication = options.getApplication
-      ? runtimeHost.normalizeApplication(options.getApplication())
-      : normalizedApplication;
-    const webResponse = await executeNodeJavascriptApplication(activeApplication, adapted.request, {
-      capabilities,
-      effectAdapter,
-      config,
-      secrets,
-      kv,
-      application: options.application,
-      requestHeaders: adapted.headerPairs,
-      signal: options.signal || adapted.request.signal,
-      fetchImplementation: options.fetchImplementation,
-      s3: options.s3 || options.bindings && options.bindings.s3,
-      s3FetchImplementation: options.s3FetchImplementation,
-      assetsLookup: options.assetsLookup,
-      gripBroadcast: options.gripBroadcast,
-      jwtCaptureWallClock: options.jwtCaptureWallClock,
-      assets: options.assets,
-      grip: options.grip,
-      maxEffects: options.maxEffects,
-      kvClock: options.kvClock, deadlineMonotonicMs: options.deadlineMonotonicMs,
-      maxRequestBodyBytes: options.maxRequestBodyBytes ?? options.maxBodyBytes,
-      maxFetchBodyBytes: options.maxFetchBodyBytes,
-      maxStructuredBodyBytes: options.maxStructuredBodyBytes,
-      maxBindingNameBytes: options.maxBindingNameBytes,
-      maxBindingValueBytes: options.maxBindingValueBytes,
-      maxKvNamespaceBytes: options.maxKvNamespaceBytes,
-      maxKvKeyBytes: options.maxKvKeyBytes,
-      maxKvValueBytes: options.maxKvValueBytes,
-      maxKvValueDepth: options.maxKvValueDepth,
-      maxKvValueEntries: options.maxKvValueEntries,
-      schemaCodecs,
-      strict: options.strict === true,
-      provider: options.provider || 'node',
-      redactionValues: options.redactionValues,
-      onJsonTrace: options.onJsonTrace,
-      onEffectObservation: options.onEffectObservation,
-      onEffectSummary: options.onEffectSummary
-    });
-    await writeWebResponseToNode(webResponse, response, { requestMethod: adapted.method });
-    if (typeof options.onRequest === 'function') {
-      options.onRequest(Object.freeze({
-        method: adapted.method,
-        url: adapted.request.url,
-        path: new URL(adapted.request.url).pathname,
-        status: webResponse.status,
-        durationMs: Number(process.hrtime.bigint() - started) / 1e6
-      }));
-    }
-    return webResponse;
+    const budget = runtimeHost.createRequestBudget(options);
+    try {
+      budget.check();
+      const adapted = await budget.race(nodeRequestToWebRequest(request, { ...options, signal: budget.signal }));
+      const requestContext = Object.freeze({
+        request,
+        response,
+        webRequest: adapted.request,
+        signal: budget.signal,
+        headerPairs: adapted.headerPairs
+      });
+      const resolve = value => { budget.check(); return budget.race(resolveRequestOption(value, requestContext)); };
+      const requestedCapabilities = await resolve(options.capabilities);
+      const effectAdapter = await resolve(options.effectAdapter);
+      const schemaCodecs = await resolve(options.schemaCodecs);
+      const config = hasDynamicBindings ? await resolve(options.config) : options.config;
+      const secrets = hasDynamicBindings ? await resolve(options.secrets) : options.secrets;
+      const kv = hasDynamicBindings ? await resolve(options.kv) : options.kv;
+      const bindings = staticBindings || createNodeJavascriptBindingCapabilities({
+        config, secrets, kv,
+        kvReference: options.kvReference,
+        maxBindingNameBytes: options.maxBindingNameBytes,
+        maxBindingValueBytes: options.maxBindingValueBytes,
+        maxKvNamespaceBytes: options.maxKvNamespaceBytes,
+        maxKvKeyBytes: options.maxKvKeyBytes,
+        maxKvValueBytes: options.maxKvValueBytes,
+        maxKvValueDepth: options.maxKvValueDepth,
+        maxKvValueEntries: options.maxKvValueEntries
+      });
+      const capabilities = effectAdapter === undefined
+        ? withNodeBindingCapabilities(requestedCapabilities, { bindings })
+        : requestedCapabilities;
+      const started = process.hrtime.bigint();
+      const activeApplication = options.getApplication
+        ? runtimeHost.normalizeApplication(options.getApplication())
+        : normalizedApplication;
+      const webResponse = await executeNodeJavascriptApplication(activeApplication, adapted.request, {
+        capabilities,
+        effectAdapter,
+        config,
+        secrets,
+        kv,
+        application: options.application,
+        requestHeaders: adapted.headerPairs,
+        signal: budget.signal,
+        requestBudget: budget, requestClock: options.requestClock,
+        fetchImplementation: options.fetchImplementation,
+        s3: options.s3 || options.bindings && options.bindings.s3,
+        s3FetchImplementation: options.s3FetchImplementation,
+        assetsLookup: options.assetsLookup,
+        gripBroadcast: options.gripBroadcast,
+        jwtCaptureWallClock: options.jwtCaptureWallClock,
+        assets: options.assets,
+        grip: options.grip,
+        maxEffects: options.maxEffects,
+        kvClock: options.kvClock, deadlineMonotonicMs: options.deadlineMonotonicMs,
+        maxRequestBodyBytes: options.maxRequestBodyBytes ?? options.maxBodyBytes,
+        maxFetchBodyBytes: options.maxFetchBodyBytes,
+        maxStructuredBodyBytes: options.maxStructuredBodyBytes,
+        maxBindingNameBytes: options.maxBindingNameBytes,
+        maxBindingValueBytes: options.maxBindingValueBytes,
+        maxKvNamespaceBytes: options.maxKvNamespaceBytes,
+        maxKvKeyBytes: options.maxKvKeyBytes,
+        maxKvValueBytes: options.maxKvValueBytes,
+        maxKvValueDepth: options.maxKvValueDepth,
+        maxKvValueEntries: options.maxKvValueEntries,
+        schemaCodecs,
+        strict: options.strict === true,
+        provider: options.provider || 'node',
+        redactionValues: options.redactionValues,
+        onJsonTrace: options.onJsonTrace,
+        onEffectObservation: options.onEffectObservation,
+        onEffectSummary: options.onEffectSummary
+      });
+      await writeWebResponseToNode(webResponse, response, { requestMethod: adapted.method, signal: budget.signal, requestBudget: budget });
+      if (typeof options.onRequest === 'function') {
+        options.onRequest(Object.freeze({
+          method: adapted.method,
+          url: adapted.request.url,
+          path: new URL(adapted.request.url).pathname,
+          status: webResponse.status,
+          durationMs: Number(process.hrtime.bigint() - started) / 1e6
+        }));
+      }
+      return webResponse;
+    } finally { if (!options.requestBudget) budget.close(); }
   };
 }
 

package/src/javascript/package-effects.js

@@ -30,6 +30,7 @@ function unavailable(effect) {
 function createNodeJavascriptPackageEffectCapabilities(options = {}) {
   const assetsLookup = options.assetsLookup || (options.assets && options.assets.lookup);
   const gripBroadcast = options.gripBroadcast || (options.grip && options.grip.broadcast);
+  const digestText = require('@pulse-compute/crypto/provider').createJavascriptTextDigest(options);
   const jwtVerify = options.jwtVerify || (options.jwt && options.jwt.verify);
   const s3 = options.s3;
   return Object.freeze({
@@ -39,6 +40,7 @@ function createNodeJavascriptPackageEffectCapabilities(options = {}) {
         if (typeof s3 !== 'function') return unavailable(effect);
         return s3(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);
@@ -63,7 +65,8 @@ function withNodePackageEffectCapabilities(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'
         || effect.contractId === 'pulse.s3'

package/src/javascript/runtime-host.js

@@ -44,7 +44,10 @@ function nodeJavascriptProviderCapabilities(options) {
     maxKvValueDepth: options.maxKvValueDepth,
     maxKvValueEntries: options.maxKvValueEntries
   };
-  const bindingCapabilities = withNodeBindingCapabilities(options.capabilities, bindingOptions);
+  const bindingCapabilities = Object.freeze({
+    time: () => runtimeHost.readWallTime(options.wallClock === undefined ? () => Date.now() : options.wallClock),
+    ...withNodeBindingCapabilities(options.capabilities, bindingOptions)
+  });
   const configuredGripBroadcast = options.gripBroadcast
     || (options.grip && options.grip.broadcast)
     || (options.grip && options.grip.publishEndpoint
@@ -67,6 +70,7 @@ function nodeJavascriptProviderCapabilities(options) {
       assetsLookup: configuredAssetsLookup,
       gripBroadcast: configuredGripBroadcast,
       jwtVerify: configuredJwtVerify,
+      digestSubtle: options.digestSubtle,
       s3: createNodeJavascriptS3(options, bindingCapabilities.secret),
       assets: options.assets,
       grip: options.grip
@@ -90,6 +94,7 @@ async function executeNodeJavascriptApplication(application, request, options =
     application: options.application,
     requestHeaders: options.requestHeaders,
     signal: options.signal,
+    maxDurationMs: options.maxDurationMs, requestBudget: options.requestBudget, requestClock: options.requestClock,
     kvClock: options.kvClock, deadlineMonotonicMs: options.deadlineMonotonicMs,
     maxEffects: options.maxEffects,
     maxRequestBodyBytes: options.maxRequestBodyBytes,

package/src/javascript/s3.js

@@ -12,7 +12,7 @@ function createNodeJavascriptS3(options, secretLookup) {
     try { selected = bindJavascriptDigestMac(['SHA-256', 'HMAC-SHA256']); }
     catch { selected = null; }
     return readS3(effect, {
-      s3, signal: execution.signal, registerRedactionValue: execution.registerRedactionValue,
+      s3, signal: execution.signal, requestBudget: execution.requestBudget, registerRedactionValue: execution.registerRedactionValue,
       fetchImplementation: options.s3FetchImplementation || options.fetchImplementation, cryptoTarget: 'javascript',
       cryptoVerifier: selected, cryptoRealization: selected && selected.realization
     }, (name) => secretLookup(name, execution));

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

@@ -10,6 +10,7 @@ function decision(id, status, reasonId, owner, required = true) {
 
 function classifyNodeJavascriptCapability(id, options = {}) {
   const capability = String(id);
+  if (capability === 'crypto.digestText') return decision(capability, 'eligible', 'node-javascript-crypto-sha256-runtime-builtin', 'provider-node');
   if (['s3.head', 's3.getText', 's3.putText'].includes(capability)) return decision(capability, 'eligible', 'node-s3-bounded-origin-transport', 'provider-node');
   if (isJavascriptCoreCapability(capability)) {
     return decision(capability, 'eligible', 'node-router-context-parity', 'provider-node');
@@ -76,6 +77,7 @@ function classifyNodeJavascriptCapability(id, options = {}) {
 
 function classifyNodeJavascriptProviderRequirement(id, compilerCapabilities, options = {}) {
   const requirement = String(id);
+  if (requirement === 'crypto.digestText') return decision(requirement, 'eligible', 'node-javascript-crypto-sha256-runtime-builtin', 'provider-node');
   if (['s3.head', 's3.getText', 's3.putText'].includes(requirement)) return decision(requirement, 'eligible', 'node-s3-bounded-origin-transport', 'provider-node');
   if (requirement === 'request') {
     const bodyRequired = compilerCapabilities.some((entry) => entry === 'request.json' || entry.startsWith('request.body'));

package/src/javascript/test-runtime.js

@@ -60,6 +60,7 @@ async function executeNodeJavascriptTestCase(application, testCase, options = {}
     kv: testCase.kv || {},
     application: options.application,
     requestHeaders: adapted.headerPairs,
+    maxDurationMs: options.maxDurationMs, requestClock: options.requestClock, requestBudget: options.requestBudget, signal: options.signal,
     maxEffects: options.maxEffects,
     maxRequestBodyBytes: options.maxRequestBodyBytes ?? options.maxBodyBytes ?? testCase.maxBodyBytes,
     maxFetchBodyBytes: options.maxFetchBodyBytes ?? testCase.maxBodyBytes,

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

@@ -198,7 +198,7 @@ function responseIsStructured(method, headers, status = 200) {
     || contentType.includes('application/x-www-form-urlencoded');
 }
 
-async function readStructuredResponseText(response, maxBytes) {
+async function readStructuredResponseText(response, maxBytes, signal) {
   const limit = Number.isSafeInteger(Number(maxBytes)) && Number(maxBytes) > 0 ? Number(maxBytes) : 65_536;
   const declared = Number(response.headers && response.headers.get && response.headers.get('content-length'));
   if (Number.isSafeInteger(declared) && declared > limit) {
@@ -206,11 +206,16 @@ async function readStructuredResponseText(response, maxBytes) {
   }
   if (!response.body) return '';
   const reader = response.body.getReader();
+  const cancel = () => { Promise.resolve(reader.cancel(signal.reason)).catch(() => {}); };
+  if (signal?.aborted) cancel();
+  else signal?.addEventListener('abort', cancel, { once: true });
   const chunks = [];
   let bytes = 0;
   try {
     while (true) {
+      signal?.throwIfAborted();
       const result = await reader.read();
+      signal?.throwIfAborted();
       if (result.done) break;
       const chunk = result.value instanceof Uint8Array ? result.value : new Uint8Array(result.value || 0);
       bytes += chunk.byteLength;
@@ -221,6 +226,7 @@ async function readStructuredResponseText(response, maxBytes) {
       chunks.push(chunk);
     }
   } finally {
+    signal?.removeEventListener('abort', cancel);
     try { reader.releaseLock(); } catch (_) { /* already released */ }
   }
   const output = new Uint8Array(bytes);
@@ -234,9 +240,13 @@ async function readStructuredResponseText(response, maxBytes) {
 
 async function executeLiveFetch(normalized, fetchImplementation, options = {}) {
   const timeoutMs = Number(normalized.init.timeoutMs);
-  const controller = Number.isFinite(timeoutMs) && timeoutMs > 0 ? new AbortController() : undefined;
-  const timeout = controller ? setTimeout(() => controller.abort(new Error(`Fetch timed out after ${timeoutMs}ms.`)), timeoutMs) : undefined;
+  const controller = new AbortController();
+  const cancel = () => controller.abort(options.signal.reason);
+  if (options.signal?.aborted) cancel();
+  else options.signal?.addEventListener('abort', cancel, { once: true });
+  const timeout = Number.isFinite(timeoutMs) && timeoutMs > 0 ? setTimeout(() => controller.abort(new Error(`Fetch timed out after ${timeoutMs}ms.`)), timeoutMs) : undefined;
   try {
+    controller.signal.throwIfAborted();
     const response = await fetchImplementation(normalized.parts.url, {
       method: normalized.init.method,
       headers: normalized.init.headers,
@@ -244,6 +254,10 @@ async function executeLiveFetch(normalized, fetchImplementation, options = {}) {
       signal: controller && controller.signal,
       redirect: 'follow'
     });
+    if (controller.signal.aborted) {
+      if (response.body) void response.body.cancel(controller.signal.reason).catch(() => {});
+      throw controller.signal.reason;
+    }
     const headers = responseHeaders(response);
     const responseMode = normalized.responseMode || 'auto';
     const structured = responseMode === 'structured'
@@ -251,12 +265,22 @@ async function executeLiveFetch(normalized, fetchImplementation, options = {}) {
     if (structured) {
       const body = normalized.init.method === 'HEAD' || !responseStatusAllowsBody(response.status)
         ? ''
-        : await readStructuredResponseText(response, options.maxFetchBodyBytes || options.maxBodyBytes);
+        : await readStructuredResponseText(response, options.maxFetchBodyBytes || options.maxBodyBytes, controller.signal);
       return { status: response.status, kind: 'text', headers, body };
     }
     const bodyStream = response.body && typeof Readable.fromWeb === 'function' ? Readable.fromWeb(response.body) : response.body;
+    if (bodyStream && options.requestBudget) {
+      // Until normal handoff, the request still owns an opaque result. A late
+      // response after expiry must be disposed without an unhandled error.
+      if (typeof bodyStream.on === 'function') bodyStream.on('error', () => {});
+      options.requestBudget.onAbort(() => {
+        if (typeof bodyStream.destroy === 'function') bodyStream.destroy(options.requestBudget.signal.reason);
+        else if (!bodyStream.locked) void bodyStream.cancel(options.requestBudget.signal.reason).catch(() => {});
+      });
+    }
     return { status: response.status, kind: 'stream', headers, bodyStream };
   } catch (error) {
+    options.signal?.throwIfAborted();
     if ((controller && controller.signal.aborted) || error && error.name === 'AbortError') {
       throw new hostRuntime.CanonicalRuntimeError('FetchTimeoutError', 'PULSE_FETCH_TIMEOUT', 'Live Node fetch exceeded the configured timeout.', { effectId: normalized.id, url: normalized.parts.url, timeoutMs });
     }
@@ -264,6 +288,7 @@ async function executeLiveFetch(normalized, fetchImplementation, options = {}) {
     throw new hostRuntime.CanonicalRuntimeError('FetchNetworkError', 'PULSE_FETCH_NETWORK', `Live Node fetch failed for ${normalized.init.method} ${normalized.parts.url}.`, { effectId: normalized.id, url: normalized.parts.url, message: error && error.message ? error.message : String(error) });
   } finally {
     if (timeout) clearTimeout(timeout);
+    options.signal?.removeEventListener('abort', cancel);
   }
 }
 
@@ -501,6 +526,8 @@ function createNodeProviderAdapter(baseOptions = {}) {
     },
     dispatchFetch,
     async dispatchEffect(effect, executionOptions = {}) {
+      if (effect.kind === 'crypto.digestText') return require('@pulse-compute/crypto/provider').executeTextDigest(effect, executionOptions);
+      if (effect.kind === 'time.now') return portableRuntimeHost.readWallTime(baseOptions.wallClock === undefined ? () => Date.now() : baseOptions.wallClock);
       if (['s3.head', 's3.getText', 's3.putText'].includes(effect.kind)) {
         return require('./s3-reader.js').readS3(effect, { ...baseOptions, ...executionOptions,
           fetchImplementation: executionOptions.s3FetchImplementation || baseOptions.s3FetchImplementation

package/src/runtime/s3-reader.js

@@ -54,6 +54,7 @@ async function readS3(effect, options, lookup) {
   let timedOut = false;
   const deadline = performance.now() + binding.timeoutMs;
   const check = () => {
+    options.requestBudget?.check();
     if (performance.now() >= deadline) { timedOut = true; controller.abort(); }
     if (controller.signal.aborted) throw controller.signal.reason || new Error('S3 deadline expired.');
   };
@@ -65,7 +66,9 @@ async function readS3(effect, options, lookup) {
     if (key === null) return failure('invalid-key');
     let body, contentType;
     if (put) {
-      if (typeof payload.text !== 'string' || !payload.text.isWellFormed()) return failure('invalid-text');
+      if (typeof payload.text !== 'string') return failure('invalid-text');
+      if (payload.text.length > binding.maxTextBytes) return failure('too-large');
+      if (!payload.text.isWellFormed()) return failure('invalid-text');
       body = protocol.bytes(payload.text);
       if (body.length > binding.maxTextBytes) return failure('too-large');
       try { contentType = protocol.normalizePutOptions({ contentType: payload.contentType }).contentType; }

package/src/toolchain.js

@@ -36,7 +36,7 @@ function genericProviderConfig(value) {
   const input = value && typeof value === 'object' ? value : {};
   const bindings = input.bindings || {};
   if (Object.keys(bindings).some((key) => key !== 's3')) throw new TypeError('Unknown Node binding field.');
-  return Object.freeze({ kind: 'node', bindings: Object.freeze({ s3: require('./config/s3.js').normalizeNodeS3(bindings.s3) }), local: Object.freeze({}) });
+  return Object.freeze({ kind: 'node', maxDurationMs: require('@pulse-compute/runtime/host').normalizeRequestDuration(input.maxDurationMs), bindings: Object.freeze({ s3: require('./config/s3.js').normalizeNodeS3(bindings.s3) }), local: Object.freeze({}) });
 }
 
 function nodeRealization(nativeArtifact) {
@@ -144,18 +144,19 @@ function createDriver() {
     normalizeConfig: genericProviderConfig,
     configReference: Object.freeze({
       sections: [{ id: 'node', title: 'Node provider options', description: 'Provider-owned Node profile configuration.' }],
-      fields: [{ section: 'node', path: 'node.bindings.s3', type: 'Readonly<Record<string, S3Binding>>', default: '`{}`', scope: 'Node Native and JavaScript S3',
-        description: 'Maps literal logical names to fixed HTTPS endpoint, bucket, region, accessKeyIdSecret, secretAccessKeySecret, optional sessionTokenSecret, maxTextBytes (1–32768, default 32768) and timeoutMs (1–30000, default 10000).',
+      fields: [{ section:'node', path:'node.maxDurationMs', type:'integer', allowed:'1–30000', default:'omitted', scope:'HTTP request execution', description:'One provider-owned monotonic budget shared by request effects and continuations; expiry does not prove rollback of dispatched writes.' }, { section: 'node', path: 'node.bindings.s3', type: 'Readonly<Record<string, S3Binding>>', default: '`{}`', scope: 'Node Native and JavaScript S3',
+        description: 'Maps literal logical names to fixed HTTPS endpoint, bucket, region, accessKeyIdSecret, secretAccessKeySecret, optional sessionTokenSecret, maxTextBytes (1–2097152, default 32768) and timeoutMs (1–30000, default 10000).',
         security: 'Only named credential references are configuration. Runtime keys cannot override authority.' }]
     }),
     defaultLocalNetworkFetch: true,
-    projectConfigDocument(config) { return Object.keys(config.bindings.s3).length ? config : undefined; },
+    projectConfigDocument(config) { return (Object.keys(config.bindings.s3).length || config.maxDurationMs !== undefined) ? config : undefined; },
     initTemplate() {
       return Object.freeze({ profileFragment: '', dependencies: Object.freeze({}) });
     },
     executionOptions(config, values) {
       return Object.freeze({
         ...values,
+        maxDurationMs: config.maxDurationMs,
         s3: config.bindings.s3,
         s3FetchImplementation: values.s3FetchImplementation || require('./javascript/fetch-adapter.js').createNodeJavascriptFixtureFetch(
           values.fetches || {}, values.fetchImplementation || (values.liveFetch === true ? globalThis.fetch : undefined),