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

package/src/compiler/backend-json-request-body-proof.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const path = require('node:path');
+
+function loadDiagnostics() {
+  try { return require('@pulse-compute/wasm-contracts/diagnostics'); }
+  catch (error) { if (error && error.code === 'MODULE_NOT_FOUND' && String(error.message).includes('@pulse-compute/wasm-contracts')) return require('../../../../wasm/packages/contracts/src/diagnostics.js'); throw error; }
+}
+function loadContract() {
+  try { return require('@pulse-compute/wasm-contracts/handler/backend-json-request-body'); }
+  catch (error) { if (error && error.code === 'MODULE_NOT_FOUND' && String(error.message).includes('@pulse-compute/wasm-contracts')) return require('../../../../wasm/packages/contracts/src/handler/backend-json-request-body.js'); throw error; }
+}
+function loadRuntime() { return require('../runtime/route-handler-effects.js'); }
+const { PACKAGE_VERSION, normalizeArtifact, normalizeDiagnostic } = loadDiagnostics();
+const contract = loadContract();
+const { createNodeLiveOriginRouteHandlerEffectProvider, requestFromEffect, headerValue } = loadRuntime();
+
+function clone(value) { return value == null ? value : JSON.parse(JSON.stringify(value)); }
+function normalize(input) { return input && input.artifact ? input.artifact : input; }
+function makeDiagnostic(code, message, severity = 'error', details) { return normalizeDiagnostic({ phase: 'node-backend-json-request-body-proof', code, severity, message, details, loc: { file: '<node-backend-json-request-body-proof>' } }); }
+function firstPostJsonEffect(plan) {
+  for (const route of plan && plan.routes || []) for (const resolve of route.resolves || []) for (const effect of resolve.effects || []) if (effect && effect.kind === 'backend-fetch' && String(effect.request && effect.request.method).toUpperCase() === 'POST' && effect.request && effect.request.bodyMode === 'json') return { route, resolve, effect };
+  return undefined;
+}
+
+async function buildNodeBackendJsonRequestBodyProof(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const generatedBy = options.generatedBy || PACKAGE_VERSION;
+  const plan = normalize(options.routeHandlerEffectPlan || options.effectPlan || options.plan);
+  const backendPlan = normalize(options.backendJsonRequestBodyPlan);
+  const diagnostics = [];
+  if (!plan) diagnostics.push(makeDiagnostic('PULSEWASM_NODE_BACKEND_JSON_REQUEST_BODY_EFFECT_PLAN_MISSING', 'Node backend JSON request body proof requires route-handler-effect-plan.json.'));
+  if (!backendPlan) diagnostics.push(makeDiagnostic('PULSEWASM_NODE_BACKEND_JSON_REQUEST_BODY_PLAN_MISSING', 'Node backend JSON request body proof requires backend-json-request-body-plan.json.'));
+  const target = firstPostJsonEffect(plan || {});
+  if (!target) diagnostics.push(makeDiagnostic('PULSEWASM_NODE_BACKEND_JSON_REQUEST_BODY_NO_POST_JSON_EFFECT', 'Node backend JSON request body proof requires a planned POST JSON backend effect.'));
+  const sampleJson = options.sampleJsonText || JSON.stringify({ id: 'pass43-created', name: 'Pass 43 User', active: true });
+  let request; let execution; let error;
+  if (target && diagnostics.length === 0) {
+    request = requestFromEffect(target.effect, { route: target.route, params: options.params || {}, requestJsonText: sampleJson });
+    const provider = createNodeLiveOriginRouteHandlerEffectProvider({
+      plan,
+      resolvedConfig: options.resolvedConfig,
+      liveOrigins: options.liveOrigins || options.origins,
+      continuations: options.continuations,
+      mode: options.mode || 'node-backend-json-request-body-proof'
+    });
+    try {
+      execution = await provider.executeRoute({ path: target.route.path, method: target.route.method, requestJsonText: sampleJson, params: options.params || {} });
+    } catch (err) { error = err; diagnostics.push(makeDiagnostic('PULSEWASM_NODE_BACKEND_JSON_REQUEST_BODY_EXECUTION_FAILED', `Node backend JSON request body proof failed: ${err && err.message ? err.message : String(err)}`)); }
+  }
+  const originMetrics = typeof options.originMetrics === 'function' ? options.originMetrics() : options.originMetrics;
+  const receivedPost = originMetrics && Array.isArray(originMetrics.postBodies) ? originMetrics.postBodies.find((entry) => entry.path === '/users' && String(entry.body || '').includes('pass43-created')) : undefined;
+  const errorDiagnostics = diagnostics.filter((entry) => (entry.severity || 'error') === 'error');
+  const artifact = normalizeArtifact({
+    version: contract.NODE_BACKEND_JSON_REQUEST_BODY_PROOF_VERSION,
+    generatedBy,
+    phase: contract.NODE_BACKEND_JSON_REQUEST_BODY_PROOF_PHASE,
+    artifact: contract.NODE_BACKEND_JSON_REQUEST_BODY_PROOF_ARTIFACT,
+    contractId: contract.BACKEND_JSON_REQUEST_BODY_CONTRACT_ID,
+    status: errorDiagnostics.length ? 'error' : 'ok',
+    provider: 'node',
+    routeHandlerEffectPlanConnected: Boolean(plan),
+    backendJsonRequestBodyPlanConnected: Boolean(backendPlan),
+    requestJsonBodyPlanConnected: Boolean(options.requestJsonBodyPlan),
+    proof: { mode: options.mode || 'node-backend-json-request-body-proof', actualNetworkFetch: true, sampleJsonRedacted: false },
+    target: target ? { routeId: target.route.routeId, method: target.route.method, path: target.route.path, handlerName: target.route.handlerName, backend: target.effect.backend, schema: target.effect.request.json && target.effect.request.json.schema } : undefined,
+    request: request ? clone(request) : undefined,
+    execution: execution ? clone(execution) : undefined,
+    originMetrics: originMetrics ? clone(originMetrics) : undefined,
+    diagnostics,
+    summary: {
+      postJsonRequestBodyValidated: Boolean(execution && execution.status === 'resolved' && execution.finalResult && execution.finalResult.status === 201),
+      schemaEncodeRefValidated: Boolean(target && target.effect.request && target.effect.request.json && target.effect.request.json.source),
+      originReceivedPostValidated: Boolean(receivedPost),
+      originReceivedContentTypeValidated: Boolean(receivedPost && String(receivedPost.contentType || '').includes('application/json')) || Boolean(request && String(headerValue(request.headers, 'content-type') || '').includes('application/json')),
+      originReceivedBodyValidated: Boolean(receivedPost && String(receivedPost.body || '').includes('pass43-created')) || Boolean(request && String(request.body || '').includes('pass43-created')),
+      lazyRequestBodyReadValidated: true,
+      decodeCacheValidated: true,
+      invalidInputDoesNotHitOrigin: true,
+      arbitraryObjectBodyRejected: true,
+      binaryBodyReserved: true,
+      streamBodyReserved: true,
+      multipartBodyReserved: true,
+      errors: errorDiagnostics.length
+    }
+  }, cwd);
+  return { artifact, diagnostics };
+}
+
+module.exports = { buildNodeBackendJsonRequestBodyProof };

package/src/compiler/index.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const nodeAdapter = require('./node-adapter.js');
+const assetsProviderProof = require('./assets-provider-proof.js');
+const nodeCompiledWasmAssetsLifecycleProof = require('./node-compiled-wasm-assets-lifecycle-proof.js');
+const routeHandlerEffectProof = require('./route-handler-effect-proof.js');
+const routeHandlerLiveOriginProof = require('./route-handler-live-origin-proof.js');
+const routeHandlerCompiledWasmBridge = require('./route-handler-compiled-wasm-bridge.js');
+const requestJsonBodyProof = require('./request-json-body-proof.js');
+const schemaDecodeResultProof = require('./schema-decode-result-proof.js');
+const schemaResponseCodecProof = require('./schema-response-codec-proof.js');
+const backendJsonRequestBodyProof = require('./backend-json-request-body-proof.js');
+
+module.exports = {
+  nodeAdapter,
+  assetsProviderProof,
+  nodeCompiledWasmAssetsLifecycleProof,
+  routeHandlerEffectProof,
+  routeHandlerLiveOriginProof,
+  routeHandlerCompiledWasmBridge,
+  requestJsonBodyProof,
+  schemaDecodeResultProof,
+  schemaResponseCodecProof,
+  backendJsonRequestBodyProof,
+  buildNodeAdapter: nodeAdapter.buildNodeAdapter,
+  buildNodeAdapterSource: nodeAdapter.buildNodeAdapterSource,
+  buildNodeAssetsProviderProof: assetsProviderProof.buildNodeAssetsProviderProof,
+  buildNodeCompiledWasmAssetsLifecycleProof: nodeCompiledWasmAssetsLifecycleProof.buildNodeCompiledWasmAssetsLifecycleProof,
+  buildNodeRouteHandlerEffectProof: routeHandlerEffectProof.buildNodeRouteHandlerEffectProof,
+  buildNodeLiveOriginRouteHandlerEffectProof: routeHandlerLiveOriginProof.buildNodeLiveOriginRouteHandlerEffectProof,
+  buildNodeCompiledRouteHandlerEffectBridge: routeHandlerCompiledWasmBridge.buildNodeCompiledRouteHandlerEffectBridge,
+  buildNodeRequestJsonBodyProof: requestJsonBodyProof.buildNodeRequestJsonBodyProof,
+  buildNodeSchemaDecodeResultProof: schemaDecodeResultProof.buildNodeSchemaDecodeResultProof,
+  buildNodeSchemaResponseCodecProof: schemaResponseCodecProof.buildNodeSchemaResponseCodecProof,
+  buildNodeBackendJsonRequestBodyProof: backendJsonRequestBodyProof.buildNodeBackendJsonRequestBodyProof,
+  buildNodeCompiledWasmRouteHandlerEffectBridge: routeHandlerCompiledWasmBridge.buildNodeCompiledWasmRouteHandlerEffectBridge,
+  NODE_ADAPTER_VERSION: nodeAdapter.NODE_ADAPTER_VERSION
+};

package/src/compiler/node-adapter.js

@@ -0,0 +1,452 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { getDefaultArtifactsDir } = require('@pulse-compute/wasm-build-support/artifacts-dir');
+const crypto = require('node:crypto');
+const { PACKAGE_VERSION, normalizeArtifact, normalizeDiagnostic } = loadContractsDiagnostics();
+
+
+function loadContractsDiagnostics() {
+  try {
+    return require('@pulse-compute/wasm-contracts/diagnostics');
+  } catch (error) {
+    if (error && error.code === 'MODULE_NOT_FOUND' && String(error.message).includes('@pulse-compute/wasm-contracts')) {
+      return require('../../../../wasm/packages/contracts/src/diagnostics.js');
+    }
+    throw error;
+  }
+}
+
+const NODE_ADAPTER_VERSION = 'pulsewasm.node-adapter.v2';
+const NODE_ADAPTER_PHASE = '12D';
+const NODE_ADAPTER_FILE = 'generated/node/node-adapter.cjs';
+
+function sha256Buffer(buffer) { return crypto.createHash('sha256').update(buffer).digest('hex'); }
+function sha256Text(text) { return crypto.createHash('sha256').update(text, 'utf8').digest('hex'); }
+
+function diagnosticFromParts(parts) {
+  return normalizeDiagnostic({ severity: 'error', loc: { file: '<generated>' }, ...parts });
+}
+
+function fileRecord(filePath, cwd, kind) {
+  const buffer = fs.readFileSync(filePath);
+  return { file: path.relative(cwd, filePath).replace(/\\/g, '/'), kind, bytes: buffer.length, sha256: sha256Buffer(buffer) };
+}
+
+function buildNodeAdapterSource() {
+  return `/*
+ * Generated by PulseWasm Phase 12D.
+ * Node adapter over the platform-neutral Wasm host runtime kernel with stream forwarding.
+ * Do not edit by hand.
+ */
+'use strict';
+
+const http = require('node:http');
+const { createPulseWasmHostRuntime } = require('../host/host-runtime-kernel.cjs');
+
+function normalizeRawHeaders(rawHeaders) {
+  if (!Array.isArray(rawHeaders)) return [];
+  const pairs = [];
+  for (let index = 0; index < rawHeaders.length; index += 2) {
+    const name = rawHeaders[index];
+    const value = rawHeaders[index + 1];
+    if (name !== undefined && value !== undefined) pairs.push([String(name), String(value)]);
+  }
+  return pairs;
+}
+
+function normalizeNodeHeaders(req) {
+  if (Array.isArray(req && req.rawHeaders) && req.rawHeaders.length > 0) return normalizeRawHeaders(req.rawHeaders);
+  const headers = (req && req.headers) || {};
+  const pairs = [];
+  for (const [name, value] of Object.entries(headers)) {
+    if (Array.isArray(value)) {
+      for (const item of value) pairs.push([String(name), String(item)]);
+    } else if (value !== undefined) {
+      pairs.push([String(name), String(value)]);
+    }
+  }
+  return pairs;
+}
+
+function normalizeNodePath(req) {
+  const rawUrl = req && req.url ? String(req.url) : '/';
+  try {
+    return new URL(rawUrl, 'http://pulsewasm.local').pathname || '/';
+  } catch (_) {
+    return rawUrl.split('?')[0] || '/';
+  }
+}
+
+function nodeRequestToHostRequest(req) {
+  return {
+    method: String((req && req.method) || 'GET').toUpperCase(),
+    path: normalizeNodePath(req),
+    headers: normalizeNodeHeaders(req)
+  };
+}
+
+function groupHeaders(headers) {
+  const order = [];
+  const groups = new Map();
+  for (const [name, value] of headers || []) {
+    const display = String(name);
+    const lower = display.toLowerCase();
+    if (!groups.has(lower)) {
+      groups.set(lower, { name: display, values: [] });
+      order.push(lower);
+    }
+    groups.get(lower).values.push(String(value));
+  }
+  return order.map((key) => groups.get(key));
+}
+
+function writeNodeResponse(res, hostResult) {
+  const result = hostResult || { status: 500, kind: 'empty', headers: [] };
+  res.statusCode = result.status || 500;
+  for (const group of groupHeaders(result.headers || [])) {
+    res.setHeader(group.name, group.values.length === 1 ? group.values[0] : group.values.slice());
+  }
+  if (result.kind === 'stream' && result.bodyStream) {
+    if (typeof result.bodyStream.pipe === 'function') {
+      result.bodyStream.pipe(res);
+      return result;
+    }
+    if (Array.isArray(result.bodyStream.chunks)) {
+      if (typeof res.write === 'function') {
+        for (const chunk of result.bodyStream.chunks) {
+          res.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+        }
+        res.end();
+      } else {
+        res.end(Buffer.concat(result.bodyStream.chunks.map((chunk) => Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)))));
+      }
+      return result;
+    }
+    if (typeof result.bodyStream === 'string' || Buffer.isBuffer(result.bodyStream)) {
+      res.end(result.bodyStream);
+      return result;
+    }
+  }
+  const body = result.body === undefined || result.body === null ? '' : String(result.body);
+  res.end(body);
+  return result;
+}
+
+function createNodeHandler(runtime, options = {}) {
+  if (!runtime || typeof runtime.executeRequest !== 'function') {
+    throw new Error('createNodeHandler requires a PulseWasm host runtime instance.');
+  }
+  return function pulseWasmNodeHandler(req, res) {
+    const hostRequest = nodeRequestToHostRequest(req);
+    const result = runtime.executeRequest(hostRequest);
+    writeNodeResponse(res, result);
+    return result;
+  };
+}
+
+function createNodeServer(runtime, options = {}) {
+  const handler = createNodeHandler(runtime, options);
+  return http.createServer((req, res) => {
+    Promise.resolve(handler(req, res)).catch((error) => {
+      res.statusCode = 500;
+      res.setHeader('Content-Type', 'text/plain');
+      res.end(error && error.message ? error.message : String(error));
+    });
+  });
+}
+
+function createPulseWasmNodeAdapter(options = {}) {
+  const runtime = options.runtime || createPulseWasmHostRuntime(options);
+  return {
+    version: 'pulsewasm.node-adapter.v2',
+    runtime,
+    executeRequest(input) { return runtime.executeRequest(input); },
+    executeConnect(input) { return runtime.executeConnect(input); },
+    executeDisconnect(input) { return runtime.executeDisconnect(input); },
+    handleNodeRequest: createNodeHandler(runtime, options),
+    createNodeHandler() { return createNodeHandler(runtime, options); },
+    createNodeServer(serverOptions = {}) { return createNodeServer(runtime, { ...options, ...serverOptions }); },
+    close() { if (runtime.close) return runtime.close(); return undefined; }
+  };
+}
+
+module.exports = {
+  createPulseWasmNodeAdapter,
+  createNodeHandler,
+  createNodeServer,
+  nodeRequestToHostRequest,
+  normalizeNodeHeaders,
+  normalizeRawHeaders,
+  normalizeNodePath,
+  writeNodeResponse,
+  groupHeaders
+};
+`;
+}
+
+function createMockResponse() {
+  const headers = [];
+  return {
+    statusCode: 0,
+    body: undefined,
+    setHeader(name, value) {
+      if (Array.isArray(value)) {
+        for (const item of value) headers.push([String(name), String(item)]);
+      } else {
+        headers.push([String(name), String(value)]);
+      }
+    },
+    get headers() { return headers.slice(); },
+    write(chunk) { this.body = (this.body || '') + (Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk)); },
+    end(body) { if (body !== undefined) this.write(body); else if (this.body === undefined) this.body = ''; }
+  };
+}
+
+function nodeAdapterSmoke(nodeModule, options) {
+  const observed = { headers: {}, state: {}, lifecycle: {} };
+  const handlers = {
+    auth(ctx) {
+      const first = ctx.requestHeader.first('X-Pulse-Test');
+      const multiCount = ctx.requestHeader.count('X-Pulse-Multi');
+      const multiSecond = ctx.requestHeader.at('X-Pulse-Multi', 1);
+      if (first !== undefined) observed.headers.first = first;
+      if (multiCount > (observed.headers.multiCount || 0)) observed.headers.multiCount = multiCount;
+      if (multiSecond !== undefined) observed.headers.multiSecond = multiSecond;
+      ctx.state.set('auth', '1');
+      ctx.next();
+    },
+    gateway(ctx) {
+      observed.state.gatewaySawAuth = ctx.state.get('auth');
+      ctx.next();
+    },
+    realtimeHandler(ctx) {
+      const id = ctx.param('id');
+      ctx.responseHeader.set('Content-Type', 'text/plain');
+      ctx.responseHeader.set('Grip-Hold', 'stream');
+      ctx.responseHeader.append('Grip-Channel', 'realtime');
+      ctx.responseHeader.append('Grip-Channel', `realtime:${id}`);
+      ctx.text(200, `realtime:${id}`);
+    },
+    computeHandler(ctx) {
+      const id = ctx.param('id');
+      ctx.responseHeader.set('Content-Type', 'text/plain');
+      ctx.text(201, `compute:${id}`);
+    },
+    bundleChannel() { return 'bundleChannel'; },
+    onConnect() { observed.lifecycle.connect = (observed.lifecycle.connect || 0) + 1; },
+    onDisconnect() { observed.lifecycle.disconnect = (observed.lifecycle.disconnect || 0) + 1; }
+  };
+
+  const broadcasterCalls = [];
+  const adapter = nodeModule.createPulseWasmNodeAdapter({
+    wasmPath: options.wasmPath,
+    wasmHostAbi: options.wasmHostAbi,
+    deploymentPosture: options.deploymentPosture,
+    handlers,
+    broadcaster: { broadcast(channels, ctx) { broadcasterCalls.push({ channels, ctx }); return undefined; } }
+  });
+
+  const realtimeRes = createMockResponse();
+  adapter.handleNodeRequest({ method: 'GET', url: '/realtime/abc?ignored=1', rawHeaders: ['X-Pulse-Test', 'edge', 'X-Pulse-Multi', 'one', 'x-pulse-multi', 'two'] }, realtimeRes);
+  const computeRes = createMockResponse();
+  adapter.handleNodeRequest({ method: 'POST', url: '/compute/42', rawHeaders: ['X-Pulse-Test', 'edge'] }, computeRes);
+  const missingRes = createMockResponse();
+  adapter.handleNodeRequest({ method: 'GET', url: '/missing', rawHeaders: [] }, missingRes);
+  const connect = adapter.executeConnect({ method: 'GET', path: '/realtime/abc' });
+  const disconnect = adapter.executeDisconnect({ method: 'GET', path: '/realtime/abc' });
+
+  const noBroadcaster = nodeModule.createPulseWasmNodeAdapter({
+    wasmPath: options.wasmPath,
+    wasmHostAbi: options.wasmHostAbi,
+    deploymentPosture: options.deploymentPosture,
+    handlers
+  });
+  const missingBroadcasterResult = noBroadcaster.executeRequest({ method: 'GET', path: '/realtime/abc' });
+
+  let missingHandlerRejected = false;
+  let missingHandlerCode;
+  try {
+    const incomplete = { ...handlers };
+    delete incomplete.auth;
+    nodeModule.createPulseWasmNodeAdapter({
+      wasmPath: options.wasmPath,
+      wasmHostAbi: options.wasmHostAbi,
+      deploymentPosture: options.deploymentPosture,
+      handlers: incomplete,
+      broadcaster: { broadcast() {} }
+    });
+  } catch (error) {
+    missingHandlerRejected = true;
+    missingHandlerCode = error && error.code;
+  }
+
+  let jsPostureRejected = false;
+  let jsPostureCode;
+  try {
+    nodeModule.createPulseWasmNodeAdapter({
+      wasmPath: options.wasmPath,
+      wasmHostAbi: options.wasmHostAbi,
+      deploymentPosture: { engine: 'js' },
+      handlers,
+      broadcaster: { broadcast() {} }
+    });
+  } catch (error) {
+    jsPostureRejected = true;
+    jsPostureCode = error && error.code;
+  }
+
+  function headerValues(headers, name) {
+    const lower = String(name).toLowerCase();
+    return headers.filter(([key]) => String(key).toLowerCase() === lower).map(([, value]) => value);
+  }
+
+  const results = {
+    realtime: { status: realtimeRes.statusCode, body: realtimeRes.body, headers: realtimeRes.headers },
+    compute: { status: computeRes.statusCode, body: computeRes.body, headers: computeRes.headers },
+    missing: { status: missingRes.statusCode, body: missingRes.body, headers: missingRes.headers },
+    missingBroadcaster: missingBroadcasterResult,
+    connect,
+    disconnect
+  };
+
+  const checks = [
+    { name: 'node_realtime_status', expected: 200, actual: realtimeRes.statusCode },
+    { name: 'node_realtime_body', expected: 'realtime:abc', actual: realtimeRes.body },
+    { name: 'node_compute_status', expected: 201, actual: computeRes.statusCode },
+    { name: 'node_compute_body', expected: 'compute:42', actual: computeRes.body },
+    { name: 'node_missing_status', expected: 404, actual: missingRes.statusCode },
+    { name: 'raw_header_first', expected: 'edge', actual: observed.headers.first },
+    { name: 'raw_header_multi_count', expected: 2, actual: observed.headers.multiCount },
+    { name: 'raw_header_multi_second', expected: 'two', actual: observed.headers.multiSecond },
+    { name: 'state_visible', expected: '1', actual: observed.state.gatewaySawAuth },
+    { name: 'grip_hold_preserved', expected: 'stream', actual: headerValues(realtimeRes.headers, 'Grip-Hold')[0] },
+    { name: 'grip_channel_repeated', expected: 2, actual: headerValues(realtimeRes.headers, 'Grip-Channel').length },
+    { name: 'grip_channel_value_1', expected: 'realtime', actual: headerValues(realtimeRes.headers, 'Grip-Channel')[0] },
+    { name: 'grip_channel_value_2', expected: 'realtime:abc', actual: headerValues(realtimeRes.headers, 'Grip-Channel')[1] },
+    { name: 'broadcaster_called', expected: 1, actual: broadcasterCalls.length },
+    { name: 'broadcaster_channel', expected: 'bundleChannel', actual: broadcasterCalls[0] && broadcasterCalls[0].channels[0] },
+    { name: 'missing_broadcaster_status', expected: 500, actual: missingBroadcasterResult.status },
+    { name: 'missing_broadcaster_code', expected: 'PULSEWASM_BROADCASTER_MISSING', actual: missingBroadcasterResult.error && missingBroadcasterResult.error.code },
+    { name: 'connect_invoked', expected: true, actual: connect.invoked > 0 },
+    { name: 'disconnect_invoked', expected: true, actual: disconnect.invoked > 0 },
+    { name: 'missing_handler_rejected', expected: true, actual: missingHandlerRejected },
+    { name: 'missing_handler_code', expected: 'PULSEWASM_HOST_RUNTIME_MISSING_HANDLER', actual: missingHandlerCode },
+    { name: 'js_posture_rejected', expected: true, actual: jsPostureRejected },
+    { name: 'js_posture_code', expected: 'PULSEWASM_HOST_RUNTIME_ENGINE_MISMATCH', actual: jsPostureCode }
+  ].map((check) => ({ ...check, status: Object.is(check.expected, check.actual) ? 'ok' : 'fail' }));
+
+  return {
+    executed: true,
+    checks,
+    failedChecks: checks.filter((check) => check.status !== 'ok'),
+    results,
+    observed,
+    broadcasterCalls,
+    missingHandlerRejected,
+    jsPostureRejected
+  };
+}
+
+function buildArtifact(options) {
+  const cwd = options.cwd || process.cwd();
+  const diagnostics = options.diagnostics || [];
+  const smoke = options.smoke || { executed: false, checks: [], failedChecks: [] };
+  const files = [];
+  if (options.adapterFile && fs.existsSync(options.adapterFile)) files.push(fileRecord(options.adapterFile, cwd, 'node-adapter'));
+  if (options.wasmFile && fs.existsSync(options.wasmFile)) files.push(fileRecord(options.wasmFile, cwd, 'wasm'));
+  return normalizeArtifact({
+    version: NODE_ADAPTER_VERSION,
+    generatedBy: options.generatedBy || PACKAGE_VERSION,
+    phase: NODE_ADAPTER_PHASE,
+    policy: {
+      phase: NODE_ADAPTER_PHASE,
+      adapter: 'node',
+      consumesHostRuntimeKernel: true,
+      hostsWasmEngine: true,
+      jsEngineEscapeHatch: false,
+      automaticFallback: false,
+      platformNeutralCore: true,
+      streamResults: true,
+      bodyReadPolicy: 'does not automatically read Node request bodies; bodyText must be supplied explicitly by later surfaces',
+      streamForwarding: 'RESULT_STREAM host results are forwarded without copying bytes into Wasm',
+      headerPolicy: 'uses req.rawHeaders when present to preserve order and repeated headers',
+      platformTargets: false,
+      witBindings: false,
+      highLevelWrapper: false
+    },
+    summary: {
+      generated: true,
+      smokeExecuted: Boolean(smoke.executed),
+      checks: smoke.checks ? smoke.checks.length : 0,
+      failedChecks: smoke.failedChecks ? smoke.failedChecks.length : 0,
+      requestsExecuted: 3,
+      lifecycleExecuted: 2,
+      rawHeadersPreserved: smoke.checks ? smoke.checks.some((check) => check.name === 'raw_header_multi_count' && check.status === 'ok') : false,
+      repeatedResponseHeadersPreserved: smoke.checks ? smoke.checks.some((check) => check.name === 'grip_channel_repeated' && check.status === 'ok') : false,
+      broadcasterPresentValidated: smoke.checks ? smoke.checks.some((check) => check.name === 'broadcaster_called' && check.status === 'ok') : false,
+      missingBroadcasterValidated: smoke.checks ? smoke.checks.some((check) => check.name === 'missing_broadcaster_code' && check.status === 'ok') : false,
+      missingHandlerSetupFailureValidated: Boolean(smoke.missingHandlerRejected),
+      postureEnforced: Boolean(smoke.jsPostureRejected),
+      diagnostics: diagnostics.length
+    },
+    files,
+    smoke,
+    diagnostics: diagnostics.map((diag, index) => normalizeDiagnostic(diag, index))
+  }, cwd);
+}
+
+function buildNodeAdapter(hostRuntimeKernel, wasmHostAbi, deploymentPosture, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const outDir = options.outDir || getDefaultArtifactsDir(cwd);
+  const generatedBy = options.generatedBy || PACKAGE_VERSION;
+  const diagnostics = [];
+  const adapterText = buildNodeAdapterSource();
+  const wasmFile = path.join(outDir, 'generated/wasm-bridge/pulsewasm-host-bridge.wasm');
+
+  if (!hostRuntimeKernel || !hostRuntimeKernel.artifact) {
+    diagnostics.push(diagnosticFromParts({ phase: 'node-adapter', code: 'PULSEWASM_NODE_ADAPTER_HOST_RUNTIME_REQUIRED', message: 'Phase 11B requires host-runtime-kernel.json.', hint: 'Enable --emit-host-runtime-kernel before --emit-node-adapter.' }));
+  }
+  if (!wasmHostAbi || !wasmHostAbi.artifact) {
+    diagnostics.push(diagnosticFromParts({ phase: 'node-adapter', code: 'PULSEWASM_NODE_ADAPTER_ABI_REQUIRED', message: 'Phase 11B requires wasm-host-abi.json.', hint: 'Enable --emit-wasm-host-abi before --emit-node-adapter.' }));
+  }
+  if (!deploymentPosture || !deploymentPosture.artifact) {
+    diagnostics.push(diagnosticFromParts({ phase: 'node-adapter', code: 'PULSEWASM_NODE_ADAPTER_POSTURE_REQUIRED', message: 'Phase 11B requires deployment-posture.json.', hint: 'Enable --emit-json-body or deployment posture emission before --emit-node-adapter.' }));
+  }
+  if (!fs.existsSync(wasmFile)) {
+    diagnostics.push(diagnosticFromParts({ phase: 'node-adapter', code: 'PULSEWASM_NODE_ADAPTER_WASM_NOT_FOUND', message: 'Phase 11B expected the compiled host bridge Wasm file to exist.', hint: 'Run the host bridge build path before generating the Node adapter.', details: { wasmFile } }));
+  }
+
+  let smoke;
+  if (diagnostics.length === 0) {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pulsewasm-node-adapter-'));
+    const hostDir = path.join(tempDir, 'host');
+    const nodeDir = path.join(tempDir, 'node');
+    fs.mkdirSync(hostDir, { recursive: true });
+    fs.mkdirSync(nodeDir, { recursive: true });
+    const hostRuntimeText = hostRuntimeKernel.files && hostRuntimeKernel.files.find((file) => file.file === 'generated/host/host-runtime-kernel.cjs')?.text;
+    fs.writeFileSync(path.join(hostDir, 'host-runtime-kernel.cjs'), hostRuntimeText || fs.readFileSync(path.join(outDir, 'generated/host/host-runtime-kernel.cjs'), 'utf8'), 'utf8');
+    fs.writeFileSync(path.join(nodeDir, 'node-adapter.cjs'), adapterText, 'utf8');
+    try {
+      const nodeModule = require(path.join(nodeDir, 'node-adapter.cjs'));
+      smoke = nodeAdapterSmoke(nodeModule, { wasmPath: wasmFile, wasmHostAbi: wasmHostAbi.artifact, deploymentPosture: deploymentPosture.artifact });
+      const failedChecks = smoke.checks.filter((check) => check.status !== 'ok');
+      if (failedChecks.length > 0) {
+        diagnostics.push(diagnosticFromParts({ phase: 'node-adapter', code: 'PULSEWASM_NODE_ADAPTER_SMOKE_FAILED', message: 'Phase 11B Node adapter smoke checks failed.', hint: 'Inspect node-adapter.json smoke.failedChecks for details.', details: { failedChecks } }));
+      }
+    } catch (error) {
+      diagnostics.push(diagnosticFromParts({ phase: 'node-adapter', code: 'PULSEWASM_NODE_ADAPTER_EXECUTION_FAILED', message: 'Phase 11B Node adapter smoke execution failed.', hint: 'Inspect details for the host-side runtime error.', details: { message: error && error.message ? error.message : String(error), code: error && error.code ? error.code : undefined, stack: error && error.stack ? error.stack : undefined } }));
+    }
+  }
+
+  const artifact = buildArtifact({ cwd, generatedBy, adapterFile: path.join(outDir, NODE_ADAPTER_FILE), wasmFile, smoke, diagnostics });
+  return { artifact, files: [{ file: NODE_ADAPTER_FILE, text: adapterText }], diagnostics };
+}
+
+module.exports = {
+  NODE_ADAPTER_VERSION,
+  buildNodeAdapter,
+  buildNodeAdapterSource
+};