@pulse-compute/provider-node 0.0.0 → 1.0.0-beta.1

package/src/javascript/fetch-adapter.js

@@ -0,0 +1,187 @@
+'use strict';
+
+const runtimeHost = require('@pulse-compute/runtime/host');
+
+const NODE_JAVASCRIPT_FETCH_ADAPTER_VERSION = 'pulse.node-javascript-fetch-adapter.v1';
+
+function fetchError(code, message, detail, cause) {
+  const error = new runtimeHost.PulseRuntimeContractError(code, message, { cause });
+  if (detail !== undefined) Object.defineProperty(error, 'detail', { enumerable: false, value: Object.freeze({ ...detail }) });
+  return error;
+}
+
+function createNodeJavascriptFetchCapability(options = {}) {
+  const implementation = options.fetchImplementation;
+  return async function nodeJavascriptFetch(url, init = {}, execution = {}) {
+    if (typeof implementation !== 'function') {
+      throw fetchError(
+        'PULSE_FETCH_IMPLEMENTATION_UNAVAILABLE',
+        'Node JavaScript fetch is disabled or no provider-owned implementation was supplied.',
+        { url: String(url), method: String(init.method || 'GET') }
+      );
+    }
+
+    try {
+      const response = await implementation(String(url), {
+        method: init.method,
+        headers: init.headers,
+        body: init.body,
+        signal: execution.signal,
+        redirect: 'follow'
+      });
+      if (!(response instanceof Response) && !runtimeHost.isPulseFetchResponse(response)) {
+        throw fetchError(
+          'PULSE_FETCH_RESPONSE_INVALID',
+          'Node JavaScript fetch implementations must resolve to a Web Response or Pulse fetch response.',
+          { url: String(url), type: typeof response }
+        );
+      }
+      return response;
+    } catch (error) {
+      if (error instanceof runtimeHost.PulseRuntimeContractError) throw error;
+      if (execution.signal && execution.signal.aborted) {
+        const reason = execution.signal.reason;
+        if (reason instanceof runtimeHost.PulseRuntimeContractError) throw reason;
+        throw reason || error;
+      }
+      throw fetchError(
+        'PULSE_FETCH_NETWORK',
+        `Node JavaScript fetch failed for ${String(init.method || 'GET')} ${String(url)}.`,
+        { url: String(url), method: String(init.method || 'GET') },
+        error
+      );
+    }
+  };
+}
+
+function delayWithSignal(ms, signal) {
+  const delay = Math.max(0, Number(ms) || 0);
+  if (delay === 0) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    let timer;
+    const finish = (callback, value) => {
+      if (timer) clearTimeout(timer);
+      if (signal) signal.removeEventListener('abort', onAbort);
+      callback(value);
+    };
+    const onAbort = () => finish(reject, signal.reason || new DOMException('Aborted', 'AbortError'));
+    if (signal && signal.aborted) return onAbort();
+    if (signal) signal.addEventListener('abort', onAbort, { once: true });
+    timer = setTimeout(() => finish(resolve), delay);
+  });
+}
+
+function fixtureHeaderPairs(input, defaultContentType) {
+  const pairs = [];
+  const hasContentType = () => pairs.some(([name]) => String(name).toLowerCase() === 'content-type');
+  if (Array.isArray(input)) {
+    for (const pair of input) {
+      if (!Array.isArray(pair) || pair.length !== 2) throw new TypeError('Node JavaScript fetch fixture headers must be [name, value] pairs.');
+      pairs.push([String(pair[0]), String(pair[1])]);
+    }
+  } else if (input instanceof Headers) {
+    for (const [name, value] of input.entries()) pairs.push([name, value]);
+    if (typeof input.getSetCookie === 'function') {
+      const cookies = input.getSetCookie();
+      if (cookies.length > 1) {
+        for (let index = pairs.length - 1; index >= 0; index -= 1) {
+          if (pairs[index][0].toLowerCase() === 'set-cookie') pairs.splice(index, 1);
+        }
+        for (const cookie of cookies) pairs.push(['set-cookie', cookie]);
+      }
+    }
+  } else if (input && typeof input === 'object') {
+    for (const [name, value] of Object.entries(input)) pairs.push([name, String(value)]);
+  }
+  if (defaultContentType && !hasContentType()) pairs.push(['content-type', defaultContentType]);
+  return Object.freeze(pairs.map(([name, value]) => Object.freeze([name, value])));
+}
+
+function fixtureHeaders(pairs) {
+  const headers = new Headers();
+  for (const [name, value] of pairs) headers.append(name, value);
+  return headers;
+}
+
+function fixtureKey(fetches, url, method) {
+  if (!fetches || typeof fetches !== 'object') return undefined;
+  const exact = `${String(method || 'GET').toUpperCase()} ${String(url)}`;
+  return Object.prototype.hasOwnProperty.call(fetches, exact) ? exact
+    : Object.prototype.hasOwnProperty.call(fetches, String(url)) ? String(url)
+      : undefined;
+}
+
+function createNodeJavascriptFixtureFetch(fetches = {}, fallback, options = {}) {
+  return async function nodeJavascriptFixtureFetch(url, init = {}) {
+    const key = fixtureKey(fetches, url, init.method);
+    if (key === undefined) {
+      if (typeof fallback === 'function') return fallback(url, init);
+      throw new Error(`No Node JavaScript fetch fixture is configured for ${String(init.method || 'GET')} ${String(url)}.`);
+    }
+    const fixture = fetches[key] || {};
+    if (fixture.kind === 'network-error' || fixture.networkError === true) {
+      throw new Error(fixture.message || 'Configured Node JavaScript fetch network failure.');
+    }
+    if (fixture.kind === 'timeout' || fixture.timeout === true) {
+      await new Promise((_resolve, reject) => {
+        const signal = init.signal;
+        const onAbort = () => reject(signal.reason || new DOMException('Aborted', 'AbortError'));
+        if (signal && signal.aborted) onAbort();
+        else if (signal) signal.addEventListener('abort', onAbort, { once: true });
+      });
+    }
+    await delayWithSignal(fixture.delayMs, init.signal);
+
+    const status = Number(fixture.status || 200);
+    let body = null;
+    let defaultContentType;
+    if (fixture.opaque === true || Array.isArray(fixture.chunks)) {
+      const chunks = Array.isArray(fixture.chunks) ? fixture.chunks : [];
+      body = new ReadableStream({
+        start(controller) {
+          for (const chunk of chunks) controller.enqueue(typeof chunk === 'string' ? new TextEncoder().encode(chunk) : chunk);
+          controller.close();
+        }
+      });
+      defaultContentType = 'application/octet-stream';
+    } else if (Object.prototype.hasOwnProperty.call(fixture, 'value')) {
+      body = JSON.stringify(fixture.value);
+      defaultContentType = 'application/json; charset=utf-8';
+    } else if (Object.prototype.hasOwnProperty.call(fixture, 'json')) {
+      body = JSON.stringify(fixture.json);
+      defaultContentType = 'application/json; charset=utf-8';
+    } else if (Object.prototype.hasOwnProperty.call(fixture, 'text')) {
+      body = String(fixture.text);
+      defaultContentType = 'text/plain; charset=utf-8';
+    } else if (Object.prototype.hasOwnProperty.call(fixture, 'body')) {
+      body = fixture.body == null ? null : fixture.body;
+    }
+    const headerPairs = fixtureHeaderPairs(fixture.headers, defaultContentType);
+    const headers = fixtureHeaders(headerPairs);
+    const method = String(init.method || 'GET').toUpperCase();
+    const bodyAllowed = method !== 'HEAD'
+      && status !== 204
+      && status !== 205
+      && status !== 304
+      && !(status >= 100 && status < 200);
+    const response = new Response(bodyAllowed ? body : null, { status, headers });
+    if (options.rawResponse === true) return response;
+    return runtimeHost.createOpaqueFetchResponse({ response, headers: headerPairs });
+  };
+}
+
+function withNodeFetchCapability(capabilities, options = {}) {
+  const value = capabilities && typeof capabilities === 'object' ? capabilities : {};
+  if (typeof value.fetch === 'function') return value;
+  return Object.freeze({
+    ...value,
+    fetch: createNodeJavascriptFetchCapability(options)
+  });
+}
+
+module.exports = Object.freeze({
+  NODE_JAVASCRIPT_FETCH_ADAPTER_VERSION,
+  createNodeJavascriptFetchCapability,
+  createNodeJavascriptFixtureFetch,
+  withNodeFetchCapability
+});

package/src/javascript/grip-broadcast.js

@@ -0,0 +1,243 @@
+'use strict';
+
+const { PulseNodeJavascriptPackageEffectError } = require('./package-effects.js');
+
+const NODE_JAVASCRIPT_GRIP_BROADCAST_VERSION = 'pulse.node-javascript-grip-broadcast.v1';
+const DEFAULT_MAX_REQUEST_BYTES = 65536;
+const DEFAULT_MAX_RESPONSE_BYTES = 65536;
+
+function fail(code, message, detail = {}) {
+  throw new PulseNodeJavascriptPackageEffectError(code, message, detail);
+}
+
+function positiveSafeInteger(value, fallback, field) {
+  if (value === undefined) return fallback;
+  const number = Number(value);
+  if (!Number.isSafeInteger(number) || number <= 0) {
+    throw new TypeError(`Pulse Node JavaScript GRIP ${field} must be a positive safe integer.`);
+  }
+  return number;
+}
+
+function normalizeEndpoint(input) {
+  if (typeof input !== 'string' || input.trim().length === 0) {
+    fail(
+      'PULSE_GRIP_BROADCAST_CAPABILITY_REQUIRED',
+      'GRIP broadcast requires an explicitly configured provider publish endpoint.',
+      { operation: 'broadcast', configuration: 'grip.publishEndpoint' }
+    );
+  }
+  let endpoint;
+  try {
+    endpoint = new URL(input);
+  } catch {
+    fail(
+      'PULSE_GRIP_BROADCAST_ENDPOINT_INVALID',
+      'GRIP broadcast publishEndpoint must be an absolute HTTP or HTTPS URL.',
+      { operation: 'broadcast', configuration: 'grip.publishEndpoint' }
+    );
+  }
+  if (!['http:', 'https:'].includes(endpoint.protocol)) {
+    fail(
+      'PULSE_GRIP_BROADCAST_ENDPOINT_INVALID',
+      'GRIP broadcast publishEndpoint must use HTTP or HTTPS.',
+      { operation: 'broadcast', configuration: 'grip.publishEndpoint', protocol: endpoint.protocol }
+    );
+  }
+  return endpoint.href;
+}
+
+function normalizeAuthentication(input) {
+  if (input === undefined) return undefined;
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new TypeError('Pulse Node JavaScript GRIP authentication must be an object.');
+  }
+  const scheme = input.scheme === undefined ? 'bearer' : String(input.scheme).toLowerCase();
+  if (scheme !== 'bearer') {
+    fail(
+      'PULSE_GRIP_BROADCAST_AUTH_SCHEME_UNSUPPORTED',
+      'GRIP broadcast currently supports only bearer authentication.',
+      { operation: 'broadcast', scheme }
+    );
+  }
+  const secretRef = typeof input.secretRef === 'string' ? input.secretRef.trim() : '';
+  if (!secretRef) {
+    fail(
+      'PULSE_GRIP_BROADCAST_SECRET_REFERENCE_REQUIRED',
+      'GRIP bearer authentication requires a named secret reference.',
+      { operation: 'broadcast', configuration: 'grip.authentication.secretRef' }
+    );
+  }
+  return Object.freeze({ scheme, secretRef });
+}
+
+function requestBody(payload) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    fail('PULSE_GRIP_BROADCAST_MESSAGE_INVALID', 'GRIP broadcast requires a structured message.', { operation: 'broadcast' });
+  }
+  const channel = typeof payload.channel === 'string' ? payload.channel.trim() : '';
+  if (!channel || /[,\r\n]/.test(channel)) {
+    fail(
+      'PULSE_GRIP_BROADCAST_CHANNEL_INVALID',
+      'GRIP broadcast channel must be a non-empty string without commas or line breaks.',
+      { operation: 'broadcast' }
+    );
+  }
+  if (!Object.prototype.hasOwnProperty.call(payload, 'data') || payload.data === undefined) {
+    fail('PULSE_GRIP_BROADCAST_MESSAGE_INVALID', 'GRIP broadcast requires a JSON-compatible data value.', { operation: 'broadcast' });
+  }
+  try {
+    const body = JSON.stringify({
+      channel,
+      data: payload.data,
+      ...(payload.event === undefined ? {} : { event: String(payload.event) }),
+      ...(payload.id === undefined ? {} : { id: String(payload.id) })
+    });
+    if (typeof body !== 'string') throw new TypeError('not JSON serializable');
+    return body;
+  } catch {
+    fail('PULSE_GRIP_BROADCAST_MESSAGE_INVALID', 'GRIP broadcast message must be JSON-compatible.', { operation: 'broadcast' });
+  }
+}
+
+async function readBoundedResponseText(response, maxBytes) {
+  const contentLength = Number(response.headers && response.headers.get && response.headers.get('content-length'));
+  if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+    fail(
+      'PULSE_GRIP_BROADCAST_RESPONSE_TOO_LARGE',
+      'GRIP broadcast provider response exceeded the configured byte limit.',
+      { operation: 'broadcast', maxResponseBytes: maxBytes }
+    );
+  }
+  if (!response.body) return '';
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let size = 0;
+  let output = '';
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > maxBytes) {
+        await reader.cancel();
+        fail(
+          'PULSE_GRIP_BROADCAST_RESPONSE_TOO_LARGE',
+          'GRIP broadcast provider response exceeded the configured byte limit.',
+          { operation: 'broadcast', maxResponseBytes: maxBytes }
+        );
+      }
+      output += decoder.decode(value, { stream: true });
+    }
+    return output + decoder.decode();
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+function normalizeAck(status, text) {
+  if (!text.trim()) return Object.freeze({ accepted: true, status });
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    fail(
+      'PULSE_GRIP_BROADCAST_RESPONSE_INVALID',
+      'GRIP broadcast provider returned an invalid acknowledgement.',
+      { operation: 'broadcast', status }
+    );
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    fail(
+      'PULSE_GRIP_BROADCAST_RESPONSE_INVALID',
+      'GRIP broadcast provider acknowledgement must be an object.',
+      { operation: 'broadcast', status }
+    );
+  }
+  const messageId = parsed.messageId === undefined ? undefined : String(parsed.messageId);
+  return Object.freeze({
+    accepted: parsed.accepted !== false,
+    status,
+    ...(messageId === undefined ? {} : { messageId })
+  });
+}
+
+function createNodeJavascriptGripBroadcast(options = {}) {
+  const endpoint = normalizeEndpoint(options.publishEndpoint);
+  const authentication = normalizeAuthentication(options.authentication);
+  const maxRequestBytes = positiveSafeInteger(options.maxRequestBytes, DEFAULT_MAX_REQUEST_BYTES, 'maxRequestBytes');
+  const maxResponseBytes = positiveSafeInteger(options.maxResponseBytes, DEFAULT_MAX_RESPONSE_BYTES, 'maxResponseBytes');
+  const fetchImplementation = options.fetchImplementation;
+  const secretLookup = options.secretLookup;
+  if (typeof fetchImplementation !== 'function') {
+    fail(
+      'PULSE_GRIP_BROADCAST_CAPABILITY_REQUIRED',
+      'GRIP broadcast requires an explicitly supplied provider fetch implementation.',
+      { operation: 'broadcast', configuration: 'fetchImplementation' }
+    );
+  }
+
+  return async function nodeJavascriptGripBroadcast(payload, execution = {}) {
+    const body = requestBody(payload);
+    const requestBytes = new TextEncoder().encode(body).byteLength;
+    if (requestBytes > maxRequestBytes) {
+      fail(
+        'PULSE_GRIP_BROADCAST_REQUEST_TOO_LARGE',
+        'GRIP broadcast request exceeded the configured byte limit.',
+        { operation: 'broadcast', maxRequestBytes }
+      );
+    }
+    const headers = new Headers({
+      accept: 'application/json',
+      'content-type': 'application/json; charset=utf-8'
+    });
+    if (authentication) {
+      const secret = typeof secretLookup === 'function' ? await secretLookup(authentication.secretRef) : undefined;
+      if (typeof secret !== 'string' || secret.length === 0) {
+        fail(
+          'PULSE_GRIP_BROADCAST_SECRET_REQUIRED',
+          'GRIP broadcast authentication secret is unavailable.',
+          { operation: 'broadcast', secretRef: authentication.secretRef }
+        );
+      }
+      headers.set('authorization', `Bearer ${secret}`);
+    }
+
+    let response;
+    let text;
+    try {
+      response = await fetchImplementation(endpoint, {
+        method: 'POST',
+        headers,
+        body,
+        signal: execution.signal,
+        redirect: 'error'
+      });
+      if (!(response instanceof Response)) {
+        fail('PULSE_GRIP_BROADCAST_RESPONSE_INVALID', 'GRIP broadcast provider must return a Web Response.', { operation: 'broadcast' });
+      }
+      text = await readBoundedResponseText(response, maxResponseBytes);
+    } catch (error) {
+      if (error instanceof PulseNodeJavascriptPackageEffectError) throw error;
+      if (execution.signal && execution.signal.aborted) {
+        fail('PULSE_GRIP_BROADCAST_ABORTED', 'GRIP broadcast was cancelled with its owning request.', { operation: 'broadcast' });
+      }
+      fail('PULSE_GRIP_BROADCAST_NETWORK', 'GRIP broadcast provider request failed.', { operation: 'broadcast' });
+    }
+    if (response.status < 200 || response.status > 299) {
+      fail(
+        'PULSE_GRIP_BROADCAST_REJECTED',
+        'GRIP broadcast provider rejected the publication.',
+        { operation: 'broadcast', status: response.status }
+      );
+    }
+    return normalizeAck(response.status, text);
+  };
+}
+
+module.exports = Object.freeze({
+  NODE_JAVASCRIPT_GRIP_BROADCAST_VERSION,
+  DEFAULT_MAX_REQUEST_BYTES,
+  DEFAULT_MAX_RESPONSE_BYTES,
+  createNodeJavascriptGripBroadcast
+});

package/src/javascript/jwt-verifier.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const {
+  normalizeJwtVerifyEffect
+} = require('@pulse-compute/wasm-contracts/jwt/contracts');
+const {
+  CRYPTO_ES256_RUNTIME_BUILTIN_IMPLEMENTATION,
+  CRYPTO_RUNTIME_BUILTIN_IMPLEMENTATION
+} = require('@pulse-compute/wasm-contracts/crypto/contracts');
+
+const NODE_JAVASCRIPT_JWT_VERIFIER_VERSION = 'pulse.node-javascript-jwt-verifier.v2';
+const NODE_JAVASCRIPT_JWT_REALIZATIONS = Object.freeze({
+  HS256: Object.freeze({
+    algorithm: 'HS256',
+    realization: 'runtime-builtin',
+    implementation: CRYPTO_RUNTIME_BUILTIN_IMPLEMENTATION,
+    automaticFallback: false
+  }),
+  ES256: Object.freeze({
+    algorithm: 'ES256',
+    realization: 'runtime-builtin',
+    implementation: CRYPTO_ES256_RUNTIME_BUILTIN_IMPLEMENTATION,
+    automaticFallback: false
+  })
+});
+const NODE_JAVASCRIPT_JWT_REALIZATION =
+  NODE_JAVASCRIPT_JWT_REALIZATIONS.HS256;
+
+let runtimeModules;
+
+function loadRuntimeModules() {
+  if (!runtimeModules) {
+    runtimeModules = Promise.all([
+      import('@pulse-compute/jwt/provider'),
+      import('@pulse-compute/crypto')
+    ]).then(([jwtProvider, cryptoProvider]) => Object.freeze({
+      jwtProvider,
+      cryptoProvider
+    }));
+  }
+  return runtimeModules;
+}
+
+function nodeWallClock() {
+  return Object.freeze({
+    unixEpochSeconds: Date.now() / 1000,
+    trusted: true
+  });
+}
+
+function assertRequestActive(execution, jwtProvider) {
+  if (execution && execution.signal && execution.signal.aborted) {
+    throw jwtProvider.jwtError('PULSE_JWT_OPERATION_FAILED', {
+      category: 'request-cancelled',
+      automaticFallback: false
+    });
+  }
+}
+
+function assertRuntimeBuiltin(cryptoProvider, jwtProvider) {
+  if (
+    !cryptoProvider
+    || cryptoProvider.CRYPTO_RUNTIME_BUILTIN_IMPLEMENTATION !== CRYPTO_RUNTIME_BUILTIN_IMPLEMENTATION
+    || !cryptoProvider.crypto
+    || !cryptoProvider.crypto.mac
+    || typeof cryptoProvider.crypto.mac.verify !== 'function'
+    || !cryptoProvider.crypto.signature
+    || typeof cryptoProvider.crypto.signature.verify !== 'function'
+  ) {
+    throw jwtProvider.jwtError('PULSE_JWT_TARGET_UNSUPPORTED', {
+      category: 'crypto-realization',
+      realization: NODE_JAVASCRIPT_JWT_REALIZATION.realization,
+      implementation: NODE_JAVASCRIPT_JWT_REALIZATION.implementation,
+      automaticFallback: false
+    });
+  }
+  return cryptoProvider.crypto;
+}
+
+function createNodeJavascriptJwtVerify(options = {}) {
+  const captureWallClock = options.captureWallClock || nodeWallClock;
+  const secretLookup = options.secretLookup;
+  return async function verifyNodeJavascriptJwt(effect, execution) {
+    const { jwtProvider, cryptoProvider } = await loadRuntimeModules();
+    assertRequestActive(execution, jwtProvider);
+    const input = normalizeJwtVerifyEffect(effect);
+    if (execution && typeof execution.registerRedactionValue === 'function') {
+      execution.registerRedactionValue(input.token);
+    }
+    assertRequestActive(execution, jwtProvider);
+    const selectedCrypto = assertRuntimeBuiltin(cryptoProvider, jwtProvider);
+    const host = {
+      async captureWallClock() {
+        assertRequestActive(execution, jwtProvider);
+        const captured = await captureWallClock();
+        assertRequestActive(execution, jwtProvider);
+        return captured;
+      },
+      resolveSecret: typeof secretLookup === 'function'
+        ? async (binding) => {
+            assertRequestActive(execution, jwtProvider);
+            const secret = await secretLookup(binding, execution);
+            assertRequestActive(execution, jwtProvider);
+            return secret;
+          }
+        : undefined,
+      registerSensitiveValue(value) {
+        if (execution && typeof execution.registerRedactionValue === 'function') {
+          execution.registerRedactionValue(value);
+        }
+      }
+    };
+    if (execution && typeof execution.validateSchemaValue === 'function') {
+      host.validateClaims = async (schemaId, claims, context) => {
+        assertRequestActive(execution, jwtProvider);
+        const result = await execution.validateSchemaValue(schemaId, claims, context);
+        assertRequestActive(execution, jwtProvider);
+        return result;
+      };
+    }
+    const result = await jwtProvider.verifyJwtWithCrypto(
+      input,
+      Object.freeze(host),
+      selectedCrypto
+    );
+    assertRequestActive(execution, jwtProvider);
+    return result;
+  };
+}
+
+module.exports = Object.freeze({
+  NODE_JAVASCRIPT_JWT_VERIFIER_VERSION,
+  NODE_JAVASCRIPT_JWT_REALIZATION,
+  NODE_JAVASCRIPT_JWT_REALIZATIONS,
+  createNodeJavascriptJwtVerify,
+  nodeWallClock
+});

package/src/javascript/lifecycle.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const http = require('node:http');
+const { createNodeJavascriptHandler } = require('./node-adapter.js');
+
+const NODE_JAVASCRIPT_LIFECYCLE_VERSION = 'pulse.node-javascript-lifecycle.v1';
+
+function statusForError(error) {
+  if (error && error.code === 'PULSE_REQUEST_BODY_TOO_LARGE') return 413;
+  if (error && error.code === 'PULSE_NODE_REQUEST_READ_FAILED') return 400;
+  return 500;
+}
+
+function writeSafeError(response, error) {
+  if (response.headersSent) {
+    if (!response.writableEnded) response.end();
+    return;
+  }
+  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'));
+}
+
+function createNodeJavascriptServer(application, options = {}) {
+  const handler = createNodeJavascriptHandler(application, options);
+  return http.createServer((request, response) => {
+    Promise.resolve(handler(request, response)).catch((error) => {
+      writeSafeError(response, error);
+      if (typeof options.onError === 'function') options.onError(error, Object.freeze({ request, response }));
+    });
+  });
+}
+
+async function listenNodeJavascriptApplication(application, options = {}) {
+  const server = createNodeJavascriptServer(application, options);
+  const host = options.host || options.hostname || '127.0.0.1';
+  const port = options.port === undefined ? 0 : Number(options.port);
+  await new Promise((resolve, reject) => {
+    function cleanup() {
+      server.removeListener('listening', onListening);
+      server.removeListener('error', onError);
+    }
+    function onListening() {
+      cleanup();
+      resolve();
+    }
+    function onError(error) {
+      cleanup();
+      reject(error);
+    }
+    server.once('listening', onListening);
+    server.once('error', onError);
+    server.listen(port, host);
+  });
+  return server;
+}
+
+function closeNodeJavascriptServer(server) {
+  if (!server || typeof server.close !== 'function' || !server.listening) return Promise.resolve();
+  return new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+}
+
+module.exports = Object.freeze({
+  NODE_JAVASCRIPT_LIFECYCLE_VERSION,
+  closeNodeJavascriptServer,
+  createNodeJavascriptServer,
+  listenNodeJavascriptApplication,
+  statusForError
+});