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

package/src/compiler/schema-response-codec-proof.js

@@ -0,0 +1,149 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+function loadSchemaResponseContracts() {
+  const local = path.resolve(__dirname, '../../../../wasm/packages/contracts/src/handler/schema-response-codec.js');
+  if (fs.existsSync(local)) return require(local);
+  return require('@pulse-compute/wasm-contracts/handler/schema-response-codec');
+}
+function loadDiagnostics() {
+  const local = path.resolve(__dirname, '../../../../wasm/packages/contracts/src/diagnostics.js');
+  if (fs.existsSync(local)) return require(local);
+  return require('@pulse-compute/wasm-contracts/diagnostics');
+}
+function loadArtifactsDir() {
+  const local = path.resolve(__dirname, '../../../../wasm/packages/build-support/src/artifacts-dir.js');
+  if (fs.existsSync(local)) return require(local);
+  return require('@pulse-compute/wasm-build-support/artifacts-dir');
+}
+const schemaResponse = loadSchemaResponseContracts();
+const { PACKAGE_VERSION, normalizeArtifact, normalizeDiagnostic } = loadDiagnostics();
+const { getDefaultArtifactsDir } = loadArtifactsDir();
+const { createCompiledHandlerBridgeRuntime, findCompiledHandlerWasm } = require('./route-handler-compiled-wasm-bridge.js');
+
+const phaseName = 'node-schema-response-codec-proof';
+function clone(value) { if (Array.isArray(value)) return value.map(clone); if (value && typeof value === 'object') return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, clone(v)])); return value; }
+function payload(value) { return value && value.artifact && typeof value.artifact === 'object' ? value.artifact : value; }
+function normalizePlan(input) { const plan = payload(input); if (!plan || typeof plan !== 'object') return undefined; return { ...plan, routes: Array.isArray(plan.routes) ? plan.routes.map(clone) : [] }; }
+function responseRoutes(plan) { return (Array.isArray(plan && plan.routes) ? plan.routes : []).filter((route) => route && Array.isArray(route.finalResponses) && route.finalResponses.length > 0); }
+function makeDiagnostic(code, message, severity, details, hint) { return normalizeDiagnostic({ phase: phaseName, severity: severity || 'error', code, message, hint, details, loc: { file: '<node-schema-response-codec-proof>' } }); }
+function sanitize(value) { if (Array.isArray(value)) return value.map(sanitize); if (!value || typeof value !== 'object') return value; const out = {}; for (const [key, entry] of Object.entries(value)) { if (key === 'body') { out.body = String(entry || ''); out.bodyPreview = String(entry || '').slice(0, 240); } else out[key] = sanitize(entry); } return out; }
+function check(name, ok, details, failures, diagnostics) { const entry = { name, status: ok ? 'ok' : 'error', details: sanitize(details || {}) }; if (!ok) { failures.push(entry); diagnostics.push(makeDiagnostic(schemaResponse.SCHEMA_RESPONSE_CODEC_DIAGNOSTICS.compiledSmokeFailed, `Node schema response codec proof check failed: ${name}.`, 'error', entry.details)); } return entry; }
+function requestJsonRoutes(requestJsonBodyPlan) { const plan = normalizePlan(requestJsonBodyPlan); return (Array.isArray(plan && plan.routes) ? plan.routes : []).filter((route) => route.required); }
+function routeIndexFor(requestJsonRoutesList, route) { return requestJsonRoutesList.findIndex((entry) => entry.path === route.path && String(entry.method).toUpperCase() === String(route.method).toUpperCase()); }
+function runRequestJsonRoute(runtime, index, variant) { const suffix = variant === 'invalid' ? '_invalid' : variant === 'schema-missing' ? '_schema_missing' : ''; const fn = runtime.exports[`bridge_run_request_json_route_${index}${suffix}`]; if (typeof fn !== 'function') throw new Error(`Missing request JSON bridge export bridge_run_request_json_route_${index}${suffix}.`); const status = fn(); return { status, result: runtime.readResult(), bodyReadCount: runtime.requestBodyReadCount(), parseCount: runtime.requestJsonParseCount() }; }
+
+function buildNodeSchemaResponseCodecProof(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const outDir = options.outDir || getDefaultArtifactsDir(cwd);
+  const generatedBy = options.generatedBy || PACKAGE_VERSION;
+  const diagnostics = [];
+  const failures = [];
+  const checks = [];
+  const plan = normalizePlan(options.schemaResponseCodecPlan || options.plan);
+  if (!plan) diagnostics.push(makeDiagnostic(schemaResponse.SCHEMA_RESPONSE_CODEC_DIAGNOSTICS.planMissing, 'Node schema response codec proof requires schema-response-codec-plan.json.', 'error', { hint: 'Enable schema-response-codec-plan before requesting the Node proof.' }));
+  const routes = responseRoutes(plan || {}).filter((route) => route.role === 'route');
+  if (plan && routes.length === 0) diagnostics.push(makeDiagnostic(schemaResponse.SCHEMA_RESPONSE_CODEC_DIAGNOSTICS.noSchemaResponseRoutes, 'Node schema response codec proof requires at least one route using ctx.result.json("Schema", ref).', 'error', { routes: (plan.routes || []).length }));
+  const requestRoutes = requestJsonRoutes(options.requestJsonBodyPlan);
+  const wasmFile = findCompiledHandlerWasm(options.compiledHandlers, cwd, outDir, options.compiledHandlersCwd || options.sourceCwd);
+  if (!wasmFile) diagnostics.push(makeDiagnostic(schemaResponse.SCHEMA_RESPONSE_CODEC_DIAGNOSTICS.wasmMissing, 'Node schema response codec proof requires the compiled-handler Wasm artifact.', 'error', { hint: 'Enable compiled handlers together with the schema response codec proof.' }));
+  const smoke = { results: {}, checks, failedChecks: failures };
+  let runtime;
+  if (wasmFile && diagnostics.filter((entry) => (entry.severity || 'error') === 'error').length === 0) {
+    try {
+      runtime = createCompiledHandlerBridgeRuntime(wasmFile);
+      for (let i = 0; i < routes.length; i += 1) {
+        const route = routes[i];
+        const requestJsonRouteIndex = routeIndexFor(requestRoutes, route);
+        if (requestJsonRouteIndex < 0) {
+          diagnostics.push(makeDiagnostic(schemaResponse.SCHEMA_RESPONSE_CODEC_DIAGNOSTICS.compiledSmokeFailed, `Could not map schema response route ${route.method} ${route.path} to a request-json bridge route.`, 'error', { route }));
+          continue;
+        }
+        const valid = runRequestJsonRoute(runtime, requestJsonRouteIndex, 'valid');
+        smoke.results[`route${i}`] = sanitize({ route, requestJsonRouteIndex, valid });
+        checks.push(check(`schema_response_route_${i}_status`, valid.status >= 200 && valid.status < 300, valid, failures, diagnostics));
+        checks.push(check(`schema_response_route_${i}_json_kind`, valid.result.kind === 'json-text', valid.result, failures, diagnostics));
+        checks.push(check(`schema_response_route_${i}_content_type`, (valid.result.headers || []).some(([name, value]) => String(name).toLowerCase() === 'content-type' && String(value).includes('application/json')), valid.result, failures, diagnostics));
+        checks.push(check(`schema_response_route_${i}_body_encoded_from_ref`, /body-123/.test(valid.result.body || '') && /Body User/.test(valid.result.body || ''), valid.result, failures, diagnostics));
+        checks.push(check(`schema_response_route_${i}_lazy_read_once`, valid.bodyReadCount === 1, valid, failures, diagnostics));
+        checks.push(check(`schema_response_route_${i}_parse_once`, valid.parseCount === 1, valid, failures, diagnostics));
+        const missing = runRequestJsonRoute(runtime, requestJsonRouteIndex, 'schema-missing');
+        smoke.results[`route${i}Missing`] = sanitize({ route, requestJsonRouteIndex, missing });
+        checks.push(check(`schema_response_route_${i}_missing_field_status`, missing.status === 400, missing, failures, diagnostics));
+        checks.push(check(`schema_response_route_${i}_missing_field_error`, /schema_decode_failed/.test(missing.result.body || ''), missing.result, failures, diagnostics));
+      }
+      checks.push(check('schema_response_module_has_no_js_handler_imports', runtime.imports.filter((entry) => entry.module === 'pulsewasm_handlers').length === 0, { imports: runtime.imports }, failures, diagnostics));
+    } catch (error) {
+      diagnostics.push(makeDiagnostic(schemaResponse.SCHEMA_RESPONSE_CODEC_DIAGNOSTICS.compiledSmokeFailed, 'Node schema response codec proof smoke execution failed.', 'error', { message: error && error.message ? error.message : String(error), stack: error && error.stack ? error.stack : undefined }));
+    }
+  }
+  const errorDiagnostics = diagnostics.filter((entry) => (entry.severity || 'error') === 'error');
+  const compiledHandlerFiles = Array.isArray(options.compiledHandlers && options.compiledHandlers.files) ? options.compiledHandlers.files : [];
+  const compiledHandlerOutputs = Array.isArray(options.compiledHandlers && options.compiledHandlers.outputFiles) ? options.compiledHandlers.outputFiles : [];
+  const artifact = normalizeArtifact({
+    version: schemaResponse.NODE_SCHEMA_RESPONSE_CODEC_PROOF_VERSION,
+    generatedBy,
+    phase: schemaResponse.NODE_SCHEMA_RESPONSE_CODEC_PROOF_PHASE,
+    artifact: schemaResponse.NODE_SCHEMA_RESPONSE_CODEC_PROOF_ARTIFACT,
+    contractId: schemaResponse.SCHEMA_RESPONSE_CODEC_CONTRACT_ID,
+    provider: 'node',
+    status: errorDiagnostics.length === 0 ? 'ok' : 'error',
+    sourcePlanVersion: plan && plan.version,
+    sourcePlanArtifact: plan && plan.artifact,
+    schemaResponseCodecPlanConnected: Boolean(plan),
+    requestJsonBodyPlanConnected: Boolean(options.requestJsonBodyPlan),
+    compiledHandlersConnected: Boolean(options.compiledHandlers),
+    runtime: { version: schemaResponse.NODE_SCHEMA_RESPONSE_CODEC_RUNTIME_VERSION, package: '@pulse-compute/wasm-runtime-core-as/compiler/compiled-handlers', wasm: wasmFile ? path.relative(cwd, wasmFile).replace(/\\/g, '/') : undefined },
+    scope: schemaResponse.defaultNodeSchemaResponseCodecProofPolicy(),
+    surface: JSON.parse(JSON.stringify(schemaResponse.SCHEMA_RESPONSE_CODEC_SURFACE)),
+    valueKinds: JSON.parse(JSON.stringify(schemaResponse.SCHEMA_RESPONSE_CODEC_VALUE_KINDS)),
+    reserved: [...schemaResponse.SCHEMA_RESPONSE_CODEC_RESERVED_SURFACE],
+    compiledWasmRuntimeImplemented: errorDiagnostics.length === 0,
+    nodeCompiledProofImplemented: errorDiagnostics.length === 0,
+    providerNetworkFetchRequired: false,
+    backendJsonRequestBodies: false,
+    requestBodyEffects: false,
+    automaticSchemaGeneration: false,
+    typedSchemaSpecificAccessors: false,
+    arbitraryJsObjectInference: false,
+    binaryRequestBodyParsing: false,
+    streamRequestBodyParsing: false,
+    asyncAwait: false,
+    promises: false,
+    asyncify: false,
+    routes: routes.map((route) => ({ routeId: route.routeId, method: route.method, path: route.path, handlerName: route.handlerName, finalResponses: route.finalResponses })),
+    smoke,
+    summary: {
+      schemaResponseRoutes: routes.length,
+      finalJsonResponses: routes.reduce((sum, route) => sum + route.finalResponses.length, 0),
+      compiled: Boolean(wasmFile) && errorDiagnostics.length === 0,
+      executed: checks.length > 0 && errorDiagnostics.length === 0,
+      checks: checks.length,
+      failedChecks: failures.length,
+      jsonResultValidated: checks.some((entry) => entry.name.includes('json_kind') && entry.status === 'ok'),
+      contentTypeValidated: checks.some((entry) => entry.name.includes('content_type') && entry.status === 'ok'),
+      encodeFromDecodeRefValidated: checks.some((entry) => entry.name.includes('body_encoded_from_ref') && entry.status === 'ok'),
+      lazyReadValidated: checks.some((entry) => entry.name.includes('lazy_read_once') && entry.status === 'ok'),
+      parseCacheValidated: checks.some((entry) => entry.name.includes('parse_once') && entry.status === 'ok'),
+      missingFieldValidated: checks.some((entry) => entry.name.includes('missing_field_error') && entry.status === 'ok'),
+      noJsHandlerImports: checks.some((entry) => entry.name === 'schema_response_module_has_no_js_handler_imports' && entry.status === 'ok'),
+      compiledWasmRuntimeImplemented: errorDiagnostics.length === 0,
+      nodeCompiledProofImplemented: errorDiagnostics.length === 0,
+      backendJsonRequestBodies: false,
+      requestBodyEffects: false,
+      automaticSchemaGeneration: false,
+      arbitraryJsObjectInference: false,
+      diagnostics: diagnostics.length,
+      errorDiagnostics: errorDiagnostics.length,
+      errors: errorDiagnostics.length
+    },
+    generatedFiles: compiledHandlerFiles.map((file) => ({ file: file.file, bytes: file.bytes, sha256: file.sha256 })),
+    generatedOutputs: compiledHandlerOutputs.map((file) => ({ file: file.file, kind: file.kind, bytes: file.bytes, sha256: file.sha256 })),
+    diagnostics
+  }, cwd);
+  return { artifact, diagnostics, failures, files: compiledHandlerFiles, outputFiles: compiledHandlerOutputs.length ? compiledHandlerOutputs : (wasmFile ? [{ file: path.relative(cwd, wasmFile).replace(/\\/g, '/'), kind: 'compiled-handler-wasm', bytes: fs.statSync(wasmFile).size }] : []), wasmFile };
+}
+
+module.exports = { phaseName, buildNodeSchemaResponseCodecProof };

package/src/events/reference-adapter.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const runtimeHost = require('@pulse-compute/runtime/host');
+
+const NODE_EVENT_REFERENCE_ADAPTER_VERSION = 'pulse.node-event-reference-adapter.v1';
+const DEFAULT_MAX_QUEUE_DEPTH = 1024;
+
+const NODE_EVENT_ADAPTER_CODES = Object.freeze({
+  OPTIONS_INVALID: 'PULSE_NODE_EVENT_ADAPTER_OPTIONS_INVALID',
+  QUEUE_FULL: 'PULSE_NODE_EVENT_QUEUE_FULL',
+  ACCEPTANCE_FULL: runtimeHost.EVENT_EMIT_CODES.QUEUE_FULL,
+  INSTANCE_BUSY: 'PULSE_NODE_EVENT_INSTANCE_BUSY',
+  EXECUTOR_INVALID: 'PULSE_NODE_EVENT_EXECUTOR_INVALID',
+  CANCELLED: 'PULSE_NODE_EVENT_CANCELLED'
+});
+
+function adapterError(code, message, detail = {}) {
+  return new runtimeHost.PulseRuntimeContractError(code, message, {
+    detail: Object.freeze({ ...detail })
+  });
+}
+
+function requireOptions(input) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw adapterError(NODE_EVENT_ADAPTER_CODES.OPTIONS_INVALID, 'Pulse Node event adapter options must be a data object.');
+  }
+  const prototype = Object.getPrototypeOf(input);
+  const unknown = Object.keys(input).filter((key) => key !== 'id' && key !== 'maxQueueDepth').sort();
+  if ((prototype !== Object.prototype && prototype !== null) || unknown.length > 0) {
+    throw adapterError(
+      NODE_EVENT_ADAPTER_CODES.OPTIONS_INVALID,
+      'Pulse Node event adapter options contain unsupported fields.',
+      { unknown }
+    );
+  }
+  return input;
+}
+
+function createNodeEventReferenceAdapter(options = {}) {
+  const input = requireOptions(options);
+  const id = input.id === undefined ? 'pulse.node-event-reference' : input.id;
+  const maxQueueDepth = input.maxQueueDepth === undefined ? DEFAULT_MAX_QUEUE_DEPTH : input.maxQueueDepth;
+  const outbound = runtimeHost.createEventRecordingAdapter({ id, maxQueueDepth });
+  const descriptor = outbound.eventAdapter;
+  const ingress = [];
+  let draining = false;
+  let activeInvocations = 0;
+  let maximumActiveInvocations = 0;
+  let enqueuedCount = 0;
+  let completedCount = 0;
+
+  function requireNotCancelled(signal, message) {
+    if (signal && signal.aborted) {
+      throw adapterError(NODE_EVENT_ADAPTER_CODES.CANCELLED, message);
+    }
+  }
+
+  function enqueue(inputFrame, execution = {}) {
+    requireNotCancelled(execution.signal, 'Pulse Node event ingress was cancelled before host acceptance.');
+    if (ingress.length >= descriptor.maxQueueDepth) {
+      throw adapterError(
+        NODE_EVENT_ADAPTER_CODES.QUEUE_FULL,
+        `Pulse Node event adapter ${JSON.stringify(descriptor.id)} reached its bounded ingress queue capacity.`,
+        { maxQueueDepth: descriptor.maxQueueDepth }
+      );
+    }
+    const normalizer = runtimeHost.createEventRecordingAdapter({
+      id: 'pulse.node-event-ingress-normalizer',
+      maxQueueDepth: 1
+    });
+    normalizer.dispatch({ kind: 'event.emit', capability: 'event.emit', frame: inputFrame });
+    const frame = normalizer.acceptedFrames()[0];
+    ingress.push(frame);
+    enqueuedCount += 1;
+    return undefined;
+  }
+
+  function acceptOutbound(inputFrame, execution = {}) {
+    requireNotCancelled(execution.signal, 'Pulse Node event emit was cancelled before host acceptance.');
+    return outbound.dispatch({ kind: 'event.emit', capability: 'event.emit', frame: inputFrame });
+  }
+
+  async function drain(executor, execution = {}) {
+    if (typeof executor !== 'function') {
+      throw adapterError(NODE_EVENT_ADAPTER_CODES.EXECUTOR_INVALID, 'Pulse Node event adapter drain requires an executor function.');
+    }
+    if (draining) {
+      throw adapterError(
+        NODE_EVENT_ADAPTER_CODES.INSTANCE_BUSY,
+        `Pulse Node event adapter ${JSON.stringify(descriptor.id)} already owns an active instance drain.`
+      );
+    }
+    draining = true;
+    const outcomes = [];
+    try {
+      while (ingress.length > 0) {
+        const frame = ingress.shift();
+        activeInvocations += 1;
+        maximumActiveInvocations = Math.max(maximumActiveInvocations, activeInvocations);
+        let result;
+        try {
+          result = await executor(frame, Object.freeze({ signal: execution.signal, adapter: api }));
+        } finally {
+          activeInvocations -= 1;
+        }
+        completedCount += 1;
+        outcomes.push(Object.freeze({ frame, result }));
+      }
+      return Object.freeze(outcomes);
+    } finally {
+      draining = false;
+    }
+  }
+
+  const api = Object.freeze({
+    version: NODE_EVENT_REFERENCE_ADAPTER_VERSION,
+    id: descriptor.id,
+    eventAdapter: descriptor,
+    enqueue,
+    acceptOutbound,
+    emit: acceptOutbound,
+    drain,
+    pendingFrames() { return Object.freeze([...ingress]); },
+    acceptedFrames() { return outbound.acceptedFrames(); },
+    summary() {
+      return Object.freeze({
+        enqueued: enqueuedCount,
+        completed: completedCount,
+        pending: ingress.length,
+        acceptedOutbound: outbound.acceptedFrames().length,
+        activeInvocations,
+        maximumActiveInvocations,
+        draining,
+        automaticLoopback: false
+      });
+    }
+  });
+  return api;
+}
+
+module.exports = Object.freeze({
+  NODE_EVENT_REFERENCE_ADAPTER_VERSION,
+  NODE_EVENT_ADAPTER_CODES,
+  createNodeEventReferenceAdapter
+});

package/src/index.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const compiler = require('./compiler');
+const runtime = require('./runtime');
+
+module.exports = {
+  compiler,
+  runtime,
+  nodeAdapter: compiler.nodeAdapter,
+  assetsProviderProof: compiler.assetsProviderProof,
+  nodeCompiledWasmAssetsLifecycleProof: compiler.nodeCompiledWasmAssetsLifecycleProof,
+  routeHandlerEffectProof: compiler.routeHandlerEffectProof,
+  routeHandlerLiveOriginProof: compiler.routeHandlerLiveOriginProof,
+  routeHandlerCompiledWasmBridge: compiler.routeHandlerCompiledWasmBridge,
+  requestJsonBodyProof: compiler.requestJsonBodyProof,
+  schemaDecodeResultProof: compiler.schemaDecodeResultProof,
+  schemaResponseCodecProof: compiler.schemaResponseCodecProof,
+  backendJsonRequestBodyProof: compiler.backendJsonRequestBodyProof,
+  assetsProvider: runtime.assetsProvider,
+  routeHandlerEffects: runtime.routeHandlerEffects,
+  canonicalApiRuntime: runtime.canonicalApiRuntime,
+  compiledWasmNodeAdapterKv: runtime.compiledWasmNodeAdapterKv,
+  buildNodeAdapter: compiler.buildNodeAdapter,
+  buildNodeAdapterSource: compiler.buildNodeAdapterSource,
+  buildNodeAssetsProviderProof: compiler.buildNodeAssetsProviderProof,
+  buildNodeCompiledWasmAssetsLifecycleProof: compiler.buildNodeCompiledWasmAssetsLifecycleProof,
+  buildNodeRouteHandlerEffectProof: compiler.buildNodeRouteHandlerEffectProof,
+  buildNodeLiveOriginRouteHandlerEffectProof: compiler.buildNodeLiveOriginRouteHandlerEffectProof,
+  buildNodeCompiledRouteHandlerEffectBridge: compiler.buildNodeCompiledRouteHandlerEffectBridge,
+  buildNodeRequestJsonBodyProof: compiler.buildNodeRequestJsonBodyProof,
+  buildNodeSchemaDecodeResultProof: compiler.buildNodeSchemaDecodeResultProof,
+  buildNodeSchemaResponseCodecProof: compiler.buildNodeSchemaResponseCodecProof,
+  buildNodeBackendJsonRequestBodyProof: compiler.buildNodeBackendJsonRequestBodyProof,
+  buildNodeCompiledWasmRouteHandlerEffectBridge: compiler.buildNodeCompiledWasmRouteHandlerEffectBridge,
+  createPulseWasmCompiledNodeAdapterWithKv: runtime.createPulseWasmCompiledNodeAdapterWithKv,
+  createNodeAssetsProvider: runtime.createNodeAssetsProvider,
+  createNodeCompiledWasmAssetsLifecycleRuntime: runtime.createNodeCompiledWasmAssetsLifecycleRuntime,
+  createDefaultStoresFromPlan: runtime.createDefaultStoresFromPlan,
+  createNodeAssetsHandler: runtime.createNodeAssetsHandler,
+  createNodeRouteHandlerEffectProvider: runtime.createNodeRouteHandlerEffectProvider,
+  createCanonicalNodeRuntime: runtime.createCanonicalNodeRuntime,
+  executeCanonicalProgram: runtime.executeCanonicalProgram,
+  createNodeLiveOriginRouteHandlerEffectProvider: runtime.createNodeLiveOriginRouteHandlerEffectProvider,
+  createDefaultBackendsFromPlan: runtime.createDefaultBackendsFromPlan,
+  createDefaultRouteEffectBackendsFromPlan: runtime.createDefaultBackendsFromPlan,
+  normalizeLiveOriginsFromResolvedConfig: runtime.normalizeLiveOriginsFromResolvedConfig,
+  normalizeHeaders: runtime.normalizeHeaders,
+  normalizeRouteEffectHeaders: runtime.normalizeHeaders,
+  createNodeHandler: runtime.createNodeHandler,
+  createNodeServer: runtime.createNodeServer,
+  nodeRequestToHostRequest: runtime.nodeRequestToHostRequest,
+  normalizeNodeHeaders: runtime.normalizeNodeHeaders,
+  normalizeRawHeaders: runtime.normalizeRawHeaders,
+  normalizeNodePath: runtime.normalizeNodePath,
+  writeNodeResponse: runtime.writeNodeResponse,
+  groupHeaders: runtime.groupHeaders
+};

package/src/javascript/assets-adapter.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const runtimeHost = require('@pulse-compute/runtime/host');
+
+const NODE_JAVASCRIPT_ASSETS_ADAPTER_VERSION = 'pulse.node-javascript-assets-adapter.v1';
+
+function contentTypeForKey(key) {
+  const extension = String(key).toLowerCase().split('.').pop();
+  return Object.freeze({
+    css: 'text/css; charset=utf-8',
+    html: 'text/html; charset=utf-8',
+    js: 'text/javascript; charset=utf-8',
+    json: 'application/json; charset=utf-8',
+    mjs: 'text/javascript; charset=utf-8',
+    svg: 'image/svg+xml',
+    txt: 'text/plain; charset=utf-8',
+    webp: 'image/webp',
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    ico: 'image/x-icon'
+  })[extension] || 'application/octet-stream';
+}
+
+function responseHeaders(payload, found) {
+  const headers = new Headers(payload && payload.headers);
+  if (!headers.has('content-type')) {
+    headers.set(
+      'content-type',
+      found ? contentTypeForKey(payload && payload.key) : 'text/plain; charset=utf-8'
+    );
+  }
+  if (payload && payload.cacheControl !== undefined) {
+    headers.set('cache-control', String(payload.cacheControl));
+  }
+  return headers;
+}
+
+function bodyValue(value) {
+  if (value === undefined || value === null) return '';
+  if (typeof value === 'string' || Buffer.isBuffer(value) || value instanceof Uint8Array) return value;
+  return JSON.stringify(value);
+}
+
+function createNodeJavascriptAssetsLookup(bindingCapabilities) {
+  if (!bindingCapabilities || typeof bindingCapabilities.kv !== 'function') {
+    throw new TypeError('Node JavaScript Assets requires provider-owned KV capabilities.');
+  }
+  return async function nodeJavascriptAssetsLookup(payload = {}) {
+    const store = bindingCapabilities.kv(payload.store);
+    const entry = store.get(payload.key);
+    const found = entry !== undefined;
+    const headers = responseHeaders(payload, found);
+    if (!found) return runtimeHost.markOpaqueResponse(new Response(null, { status: 404, headers }));
+    const method = String(payload.method || 'GET').toUpperCase();
+    return runtimeHost.markOpaqueResponse(new Response(method === 'HEAD' ? null : bodyValue(entry), {
+      status: 200,
+      headers
+    }));
+  };
+}
+
+module.exports = Object.freeze({
+  NODE_JAVASCRIPT_ASSETS_ADAPTER_VERSION,
+  contentTypeForKey,
+  createNodeJavascriptAssetsLookup
+});

package/src/javascript/bindings-adapter.js

@@ -0,0 +1,120 @@
+'use strict';
+
+const runtimeHost = require('@pulse-compute/runtime/host');
+
+const NODE_JAVASCRIPT_BINDINGS_ADAPTER_VERSION = 'pulse.node-javascript-bindings-adapter.v1';
+
+function recordEntries(input, label = 'binding record') {
+  if (input === undefined || input === null) return [];
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new TypeError(`Pulse Node JavaScript ${label} must be an object record.`);
+  }
+  const prototype = Object.getPrototypeOf(input);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new TypeError(`Pulse Node JavaScript ${label} must be an ordinary object record.`);
+  }
+  const entries = [];
+  for (const key of Reflect.ownKeys(input)) {
+    if (typeof key !== 'string') {
+      throw new TypeError(`Pulse Node JavaScript ${label} may not contain symbol keys.`);
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    if (!descriptor || !descriptor.enumerable) continue;
+    if (!Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+      throw new TypeError(`Pulse Node JavaScript ${label} may only contain enumerable data properties.`);
+    }
+    entries.push([key, descriptor.value]);
+  }
+  return entries;
+}
+
+function createNodeJavascriptBindingCapabilities(options = {}) {
+  const config = new Map();
+  const secrets = new Map();
+  const stores = new Map();
+
+  for (const [rawName, rawValue] of recordEntries(options.config, 'config')) {
+    const name = runtimeHost.normalizeBindingName('config', rawName, options);
+    config.set(name, runtimeHost.normalizeBindingValue('config.get', name, rawValue, options));
+  }
+  for (const [rawName, rawValue] of recordEntries(options.secrets, 'secrets')) {
+    const name = runtimeHost.normalizeBindingName('secret', rawName, options);
+    secrets.set(name, runtimeHost.normalizeBindingValue('secret.get', name, rawValue, options));
+  }
+  for (const [rawNamespace, values] of recordEntries(options.kv, 'KV namespaces')) {
+    const namespace = runtimeHost.normalizeKvNamespace(rawNamespace, options);
+    const entries = new Map();
+    for (const [rawKey, value] of recordEntries(values, `KV namespace ${JSON.stringify(namespace)}`)) {
+      const key = runtimeHost.normalizeKvKey(rawKey, options);
+      entries.set(key, runtimeHost.cloneKvValue(value, options));
+    }
+    stores.set(namespace, entries);
+  }
+
+  function storeFor(namespaceInput) {
+    const namespace = runtimeHost.normalizeKvNamespace(namespaceInput, options);
+    if (!stores.has(namespace)) stores.set(namespace, new Map());
+    return Object.freeze({ namespace, store: stores.get(namespace) });
+  }
+
+  return Object.freeze({
+    version: NODE_JAVASCRIPT_BINDINGS_ADAPTER_VERSION,
+    config(nameInput) {
+      const name = runtimeHost.normalizeBindingName('config', nameInput, options);
+      return config.has(name) ? config.get(name) : undefined;
+    },
+    secret(nameInput) {
+      const name = runtimeHost.normalizeBindingName('secret', nameInput, options);
+      return secrets.has(name) ? secrets.get(name) : undefined;
+    },
+    kv(namespaceInput) {
+      const { store } = storeFor(namespaceInput);
+      return Object.freeze({
+        get(keyInput) {
+          const key = runtimeHost.normalizeKvKey(keyInput, options);
+          return runtimeHost.cloneKvValue(store.has(key) ? store.get(key) : undefined, {
+            ...options,
+            allowUndefined: true
+          });
+        },
+        put(keyInput, value) {
+          const key = runtimeHost.normalizeKvKey(keyInput, options);
+          store.set(key, runtimeHost.cloneKvValue(value, options));
+          return true;
+        }
+      });
+    }
+  });
+}
+
+function withNodeBindingCapabilities(capabilities, options = {}) {
+  const value = capabilities && typeof capabilities === 'object' ? capabilities : {};
+  const output = { ...value };
+  const needsConfig = typeof value.config !== 'function';
+  const needsSecret = typeof value.secret !== 'function';
+  const needsKv = typeof value.kv !== 'function';
+  if (!needsConfig && !needsSecret && !needsKv) return Object.freeze(output);
+  const configured = options.bindings || createNodeJavascriptBindingCapabilities(options);
+  if (needsConfig) output.config = configured.config;
+  if (needsSecret) output.secret = configured.secret;
+  if (needsKv) output.kv = configured.kv;
+  return Object.freeze(output);
+}
+
+function nodeJavascriptRedactionValues(options = {}) {
+  const output = [];
+  for (const [, value] of recordEntries(options.secrets, 'secrets')) {
+    if (typeof value === 'string' && value.length > 0) output.push(value);
+  }
+  for (const value of Array.isArray(options.redactionValues) ? options.redactionValues : []) {
+    if (typeof value === 'string' && value.length > 0) output.push(value);
+  }
+  return Object.freeze([...new Set(output)]);
+}
+
+module.exports = Object.freeze({
+  NODE_JAVASCRIPT_BINDINGS_ADAPTER_VERSION,
+  createNodeJavascriptBindingCapabilities,
+  nodeJavascriptRedactionValues,
+  withNodeBindingCapabilities
+});