@pulse-compute/wasm-host-runtime 0.0.0 → 1.0.0-beta.1

package/src/compiler/host-runtime-kernel.js

@@ -0,0 +1,690 @@
+'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 } = require('@pulse-compute/wasm-contracts/diagnostics');
+
+const HOST_RUNTIME_KERNEL_VERSION = 'pulsewasm.host-runtime-kernel.v2';
+const HOST_RUNTIME_KERNEL_PHASE = '12D';
+const HOST_RUNTIME_FILE = 'generated/host/host-runtime-kernel.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 buildHostRuntimeKernelSource() {
+  return `/*
+ * Generated by PulseWasm Phase 12D.
+ * Platform-neutral Wasm host runtime kernel with stream/pass-through result support.
+ * Do not edit by hand.
+ */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const RESULT_NONE = 0;
+const RESULT_TEXT = 1;
+const RESULT_JSON = 2;
+const RESULT_BINARY = 3;
+const RESULT_EMPTY = 4;
+const RESULT_STREAM = 5;
+
+const RESULT_KIND_NAMES = new Map([
+  [RESULT_NONE, 'none'],
+  [RESULT_TEXT, 'text'],
+  [RESULT_JSON, 'json'],
+  [RESULT_BINARY, 'binary'],
+  [RESULT_EMPTY, 'empty'],
+  [RESULT_STREAM, 'stream']
+]);
+
+const ERROR_BROADCASTER_MISSING = {
+  code: 'PULSEWASM_BROADCASTER_MISSING',
+  message: 'Channel routing resolved channels, but no broadcaster adaptor was provided.',
+  statusCode: 500
+};
+
+function normalizeHandlerRegistry(input) {
+  if (input instanceof Map) return new Map(input);
+  if (!input || typeof input !== 'object') return new Map();
+  return new Map(Object.entries(input));
+}
+
+function normalizeHeaders(headers) {
+  if (!headers) return [];
+  if (Array.isArray(headers)) return headers.map((pair) => Array.isArray(pair) ? [String(pair[0]), String(pair[1])] : [String(pair.name), String(pair.value)]);
+  if (typeof headers[Symbol.iterator] === 'function') return Array.from(headers, ([name, value]) => [String(name), String(value)]);
+  return Object.entries(headers).map(([name, value]) => [String(name), String(value)]);
+}
+
+function methodNameToCode(exports, method) {
+  const upper = String(method || '').toUpperCase();
+  if (upper === 'GET') return exports.pulse_bridge_method_get();
+  if (upper === 'POST') return exports.pulse_bridge_method_post();
+  return 0;
+}
+
+function createSetupError(code, message, details) {
+  const error = new Error(message);
+  error.code = code;
+  error.details = details;
+  return error;
+}
+
+function createPulseWasmHostRuntime(options = {}) {
+  const wasmBytes = options.wasmBytes || (options.wasmPath ? fs.readFileSync(path.resolve(options.wasmPath)) : undefined);
+  if (!wasmBytes) throw createSetupError('PULSEWASM_HOST_RUNTIME_WASM_REQUIRED', 'createPulseWasmHostRuntime requires wasmBytes or wasmPath.');
+
+  const wasmHostAbi = options.wasmHostAbi || {};
+  const deploymentPosture = options.deploymentPosture || {};
+  const postureEngine = deploymentPosture.engine || 'wasm';
+  if (postureEngine === 'js' && !options.allowJsEngine) {
+    throw createSetupError(
+      'PULSEWASM_HOST_RUNTIME_ENGINE_MISMATCH',
+      'deployment-posture.json selected the JS engine; the Wasm host runtime refuses to run without allowJsEngine override.',
+      { engine: postureEngine }
+    );
+  }
+
+  const requiredHandlers = (((wasmHostAbi.imports || {}).handlers) || []).map((handler) => ({ ...handler }));
+  const handlers = normalizeHandlerRegistry(options.handlers);
+  const missingHandlers = requiredHandlers.filter((handler) => !handlers.has(handler.name));
+  if (missingHandlers.length > 0) {
+    throw createSetupError(
+      'PULSEWASM_HOST_RUNTIME_MISSING_HANDLER',
+      'Host runtime handler registry is missing one or more generated handler imports.',
+      { missingHandlers: missingHandlers.map((handler) => handler.name) }
+    );
+  }
+
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  const module = new WebAssembly.Module(wasmBytes);
+  let instance;
+  const calls = { handlers: [], broadcasts: [], lifecycle: [] };
+  const channelRefMap = new Map();
+  const hostResponseRefMap = new Map();
+  const hostStreamRefMap = new Map();
+  let nextSyntheticChannelRef = 0xC000;
+  let nextSyntheticHostRef = 0xD000;
+
+  function memory() { return instance.exports.memory; }
+
+  function allocBytes(text) {
+    const bytes = encoder.encode(String(text ?? ''));
+    const ptr = instance.exports.pulse_alloc(bytes.length || 1);
+    new Uint8Array(memory().buffer, ptr, bytes.length).set(bytes);
+    return { ptr, len: bytes.length, text: String(text ?? '') };
+  }
+
+  function readBytes(ptr, len) {
+    if (!ptr || !len) return '';
+    return decoder.decode(new Uint8Array(memory().buffer, ptr, len));
+  }
+
+  function readStringRef(ref) {
+    if (!ref) return undefined;
+    return readBytes(instance.exports.pulse_string_ptr(ref), instance.exports.pulse_string_len(ref));
+  }
+
+  function makeErrorRef(code, message, statusCode) {
+    const c = allocBytes(code);
+    const m = allocBytes(message);
+    return instance.exports.pulse_error(c.ptr, c.len, m.ptr, m.len, statusCode || 500);
+  }
+
+  function decodeErrorRef(errorRef) {
+    if (!errorRef) return undefined;
+    return {
+      code: readStringRef(instance.exports.pulse_error_code_ref(errorRef)),
+      message: readStringRef(instance.exports.pulse_error_message_ref(errorRef)),
+      statusCode: instance.exports.pulse_error_status_code(errorRef),
+      causeRef: instance.exports.pulse_error_cause_ref(errorRef)
+    };
+  }
+
+  function readResultHeaders() {
+    const headers = [];
+    const count = instance.exports.pulse_result_header_count ? instance.exports.pulse_result_header_count() : 0;
+    for (let index = 0; index < count; index += 1) {
+      headers.push([
+        readBytes(instance.exports.pulse_result_header_name_ptr(index), instance.exports.pulse_result_header_name_len(index)),
+        readBytes(instance.exports.pulse_result_header_value_ptr(index), instance.exports.pulse_result_header_value_len(index)),
+        instance.exports.pulse_result_header_mode ? instance.exports.pulse_result_header_mode(index) : 2
+      ]);
+    }
+    return headers;
+  }
+
+  function readResultHeaderDeletes() {
+    const deletes = [];
+    const count = instance.exports.pulse_result_header_delete_count ? instance.exports.pulse_result_header_delete_count() : 0;
+    for (let index = 0; index < count; index += 1) {
+      deletes.push(readBytes(instance.exports.pulse_result_header_delete_name_ptr(index), instance.exports.pulse_result_header_delete_name_len(index)).toLowerCase());
+    }
+    return deletes;
+  }
+
+  function registerHostStream(stream) {
+    const ref = nextSyntheticHostRef++;
+    hostStreamRefMap.set(ref, stream);
+    return ref;
+  }
+
+  function registerHostResponse(response) {
+    const ref = nextSyntheticHostRef++;
+    const normalized = response && typeof response === 'object' ? response : { status: 200, headers: [], bodyStream: response };
+    if (normalized.bodyStream && !normalized.streamRef) normalized.streamRef = registerHostStream(normalized.bodyStream);
+    hostResponseRefMap.set(ref, normalized);
+    return ref;
+  }
+
+  function mergeResponseHeaders(baseHeaders, resultHeaders, deletedLowerNames) {
+    const deleted = new Set((deletedLowerNames || []).map((value) => String(value).toLowerCase()));
+    const merged = [];
+    for (const [name, value] of normalizeHeaders(baseHeaders || [])) {
+      if (!deleted.has(String(name).toLowerCase())) merged.push([name, value]);
+    }
+    for (const item of resultHeaders || []) {
+      const name = item[0];
+      const value = item[1];
+      const mode = Number(item[2] || 2);
+      const lower = String(name).toLowerCase();
+      if (mode === 1) {
+        for (let i = merged.length - 1; i >= 0; i -= 1) if (String(merged[i][0]).toLowerCase() === lower) merged.splice(i, 1);
+      }
+      merged.push([String(name), String(value)]);
+    }
+    return merged;
+  }
+
+  function decodeHostResult(status) {
+    const resultStatus = instance.exports.pulse_result_status ? instance.exports.pulse_result_status() : status;
+    const kindCode = instance.exports.pulse_result_kind ? instance.exports.pulse_result_kind() : RESULT_NONE;
+    const resultHeaders = readResultHeaders();
+    const deletedHeaders = readResultHeaderDeletes();
+    const errorRef = instance.exports.pulse_result_error_ref ? instance.exports.pulse_result_error_ref() : 0;
+    const error = decodeErrorRef(errorRef);
+    if (kindCode === RESULT_STREAM) {
+      const responseRef = instance.exports.pulse_result_response_ref ? instance.exports.pulse_result_response_ref() : 0;
+      const streamRef = instance.exports.pulse_result_stream_ref ? instance.exports.pulse_result_stream_ref() : 0;
+      const response = responseRef ? hostResponseRefMap.get(responseRef) : undefined;
+      const stream = response && response.bodyStream ? response.bodyStream : hostStreamRefMap.get(streamRef);
+      const baseHeaders = response && response.headers ? response.headers : [];
+      const responseStatus = response && response.status ? Number(response.status) : 0;
+      return {
+        status: resultStatus || responseStatus || status,
+        kind: 'stream',
+        kindCode,
+        headers: mergeResponseHeaders(baseHeaders, resultHeaders, deletedHeaders),
+        bodyStream: stream,
+        streamRef,
+        responseRef,
+        response,
+        error,
+        diagnostics: error ? [{ code: error.code, message: error.message, statusCode: error.statusCode }] : []
+      };
+    }
+    const body = instance.exports.pulse_result_body_ptr ? readBytes(instance.exports.pulse_result_body_ptr(), instance.exports.pulse_result_body_len()) : '';
+    return {
+      status: resultStatus || status,
+      kind: RESULT_KIND_NAMES.get(kindCode) || 'unknown',
+      kindCode,
+      headers: resultHeaders.map(([name, value]) => [name, value]),
+      body: body || undefined,
+      error,
+      diagnostics: error ? [{ code: error.code, message: error.message, statusCode: error.statusCode }] : []
+    };
+  }
+
+  function requestHeaderClear() { if (instance.exports.pulse_bridge_request_headers_clear) instance.exports.pulse_bridge_request_headers_clear(); }
+  function requestHeaderAppend(name, value) {
+    if (!instance.exports.pulse_bridge_request_header_append) return;
+    const n = allocBytes(name);
+    const v = allocBytes(value);
+    instance.exports.pulse_bridge_request_header_append(n.ptr, n.len, v.ptr, v.len);
+  }
+
+  function ctxParam(ctxRef, name) {
+    const n = allocBytes(name);
+    return readStringRef(instance.exports.pulse_ctx_param(ctxRef, n.ptr, n.len));
+  }
+
+  function ctxStateGet(ctxRef, key) {
+    const k = allocBytes(key);
+    return readStringRef(instance.exports.pulse_ctx_state_get(ctxRef, k.ptr, k.len));
+  }
+
+  function ctxStateSet(ctxRef, key, value) {
+    const k = allocBytes(key);
+    const v = allocBytes(value);
+    instance.exports.pulse_ctx_state_set(ctxRef, k.ptr, k.len, v.ptr, v.len);
+  }
+
+  function requestHeaderFirst(ctxRef, name) {
+    const n = allocBytes(name);
+    return readStringRef(instance.exports.pulse_request_header_first(ctxRef, n.ptr, n.len));
+  }
+
+  function requestHeaderCount(ctxRef, name) {
+    const n = allocBytes(name);
+    return instance.exports.pulse_request_header_count(ctxRef, n.ptr, n.len);
+  }
+
+  function requestHeaderAt(ctxRef, name, index) {
+    const n = allocBytes(name);
+    return readStringRef(instance.exports.pulse_request_header_at(ctxRef, n.ptr, n.len, index));
+  }
+
+  function responseHeaderSet(ctxRef, name, value) {
+    const n = allocBytes(name);
+    const v = allocBytes(value);
+    instance.exports.pulse_response_header_set(ctxRef, n.ptr, n.len, v.ptr, v.len);
+  }
+
+  function responseHeaderAppend(ctxRef, name, value) {
+    const n = allocBytes(name);
+    const v = allocBytes(value);
+    instance.exports.pulse_response_header_append(ctxRef, n.ptr, n.len, v.ptr, v.len);
+  }
+
+  function responseHeaderDelete(ctxRef, name) {
+    const n = allocBytes(name);
+    instance.exports.pulse_response_header_delete(ctxRef, n.ptr, n.len);
+  }
+
+  function resultText(ctxRef, statusCode, body) {
+    const b = allocBytes(body);
+    instance.exports.pulse_result_text(ctxRef, statusCode, b.ptr, b.len);
+  }
+
+  function resultEmpty(ctxRef, statusCode) {
+    instance.exports.pulse_result_empty(ctxRef, statusCode);
+  }
+
+  function resultJsonText(ctxRef, statusCode, jsonText) {
+    const b = allocBytes(jsonText);
+    if (instance.exports.pulse_result_json_text) instance.exports.pulse_result_json_text(ctxRef, statusCode, b.ptr, b.len);
+    else {
+      responseHeaderSet(ctxRef, 'Content-Type', 'application/json');
+      resultText(ctxRef, statusCode, jsonText);
+    }
+  }
+
+  function resultStream(ctxRef, statusCode, stream) {
+    const ref = typeof stream === 'number' ? stream : registerHostStream(stream);
+    if (instance.exports.pulse_result_stream) instance.exports.pulse_result_stream(ctxRef, statusCode, ref);
+    return ref;
+  }
+
+  function resultFromResponse(ctxRef, response) {
+    const ref = typeof response === 'number' ? response : registerHostResponse(response);
+    if (instance.exports.pulse_result_from_response) instance.exports.pulse_result_from_response(ctxRef, ref);
+    return ref;
+  }
+
+  function createHandlerContext(ctxRef, handlerMeta) {
+    return {
+      ctxRef,
+      handler: handlerMeta,
+      param(name) { return ctxParam(ctxRef, name); },
+      state: {
+        get(key) { return ctxStateGet(ctxRef, key); },
+        set(key, value) { return ctxStateSet(ctxRef, key, value); }
+      },
+      requestHeader: {
+        first(name) { return requestHeaderFirst(ctxRef, name); },
+        count(name) { return requestHeaderCount(ctxRef, name); },
+        at(name, index) { return requestHeaderAt(ctxRef, name, index); }
+      },
+      responseHeader: {
+        set(name, value) { return responseHeaderSet(ctxRef, name, value); },
+        append(name, value) { return responseHeaderAppend(ctxRef, name, value); },
+        delete(name) { return responseHeaderDelete(ctxRef, name); }
+      },
+      text(status, body) { return resultText(ctxRef, status, body); },
+      empty(status) { return resultEmpty(ctxRef, status); },
+      jsonText(status, jsonText) { return resultJsonText(ctxRef, status, jsonText); },
+      stream(status, stream) { return resultStream(ctxRef, status, stream); },
+      fromResponse(response) { return resultFromResponse(ctxRef, response); },
+      next() { return instance.exports.pulse_next(ctxRef); },
+      nextError(errorRef) { return instance.exports.pulse_next_error(ctxRef, errorRef); },
+      error(code, message, statusCode) { return makeErrorRef(code, message, statusCode || 500); }
+    };
+  }
+
+  function normalizeHandlerReturn(ctx, returned) {
+    if (!returned) return;
+    if (typeof returned === 'string') return ctx.text(200, returned);
+    if (typeof returned === 'object') {
+      if (returned.kind === 'empty') return ctx.empty(returned.status || 204);
+      if (returned.kind === 'stream') return ctx.stream(returned.status || 200, returned.stream || returned.bodyStream || returned.body);
+      if (returned.kind === 'response' || returned.response !== undefined) return ctx.fromResponse(returned.response !== undefined ? returned.response : returned);
+      if (returned.kind === 'json' || returned.json !== undefined) return ctx.jsonText(returned.status || 200, returned.body !== undefined ? String(returned.body) : JSON.stringify(returned.json));
+      if (returned.body !== undefined || returned.status !== undefined) return ctx.text(returned.status || 200, returned.body === undefined ? '' : String(returned.body));
+    }
+  }
+
+  function readChannels(channelsRef) {
+    if (!channelsRef) return [];
+    if (channelRefMap.has(channelsRef)) return channelRefMap.get(channelsRef).slice();
+    if (!instance.exports.pulse_channel_count || !instance.exports.pulse_channel_ref_at) return [];
+    const count = instance.exports.pulse_channel_count(channelsRef);
+    const channels = [];
+    for (let i = 0; i < count; i += 1) {
+      const ref = instance.exports.pulse_channel_ref_at(channelsRef, i);
+      const value = readStringRef(ref);
+      if (value) channels.push(value);
+    }
+    return channels;
+  }
+
+  const handlerByName = new Map(requiredHandlers.map((handler) => [handler.name, handler]));
+  const importObject = {
+    env: {
+      abort(message, file, line, column) { throw new Error('AssemblyScript abort(' + message + ', ' + file + ', ' + line + ', ' + column + ')'); }
+    },
+    pulsewasm_handlers: {},
+    pulsewasm_broadcaster: {
+      broadcast(channelsRef, ctxRef) {
+        const channels = readChannels(channelsRef);
+        if (!options.broadcaster || typeof options.broadcaster.broadcast !== 'function') {
+          return makeErrorRef(ERROR_BROADCASTER_MISSING.code, ERROR_BROADCASTER_MISSING.message, ERROR_BROADCASTER_MISSING.statusCode);
+        }
+        calls.broadcasts.push({ channels, ctxRef });
+        const result = options.broadcaster.broadcast(channels, { ctxRef, channels });
+        if (result && result.code) return makeErrorRef(result.code, result.message || result.code, result.statusCode || 500);
+        return 0;
+      }
+    }
+  };
+
+  for (const handler of requiredHandlers) {
+    importObject.pulsewasm_handlers[handler.name] = (a, b, c) => {
+      calls.handlers.push({ name: handler.name, role: handler.primaryRole, slot: handler.slot });
+      const fn = handlers.get(handler.name);
+      if (handler.primaryRole === 'channel') {
+        const ctx = createHandlerContext(a, handler);
+        const returned = fn(ctx);
+        let channels = [];
+        if (Array.isArray(returned)) channels = returned.map((value) => String(value));
+        else if (typeof returned === 'string') channels = [returned];
+        else if (returned && typeof returned.channel === 'string') channels = [returned.channel];
+        if (channels.length === 0) return 0;
+        const syntheticRef = nextSyntheticChannelRef++;
+        channelRefMap.set(syntheticRef, channels);
+        return syntheticRef;
+      }
+      const ctxRef = handler.primaryRole === 'error' ? b : a;
+      const errRef = handler.primaryRole === 'error' ? a : 0;
+      const ctx = createHandlerContext(ctxRef, handler);
+      if (errRef) ctx.activeError = decodeErrorRef(errRef);
+      const returned = fn(ctx);
+      normalizeHandlerReturn(ctx, returned);
+      return 0;
+    };
+  }
+
+  instance = new WebAssembly.Instance(module, importObject);
+
+  function executeRequest(input) {
+    requestHeaderClear();
+    for (const [name, value] of normalizeHeaders(input.headers)) requestHeaderAppend(name, value);
+    const methodCode = methodNameToCode(instance.exports, input.method);
+    const requestPath = allocBytes(input.path || '/');
+    const status = instance.exports.pulse_execute_request(methodCode, requestPath.ptr, requestPath.len);
+    return decodeHostResult(status);
+  }
+
+  function executeLifecycle(event, input) {
+    const methodCode = methodNameToCode(instance.exports, input.method || 'GET');
+    const requestPath = allocBytes(input.path || '/');
+    const fn = event === 'connect' ? instance.exports.pulse_execute_connect : instance.exports.pulse_execute_disconnect;
+    const invoked = fn(methodCode, requestPath.ptr, requestPath.len);
+    calls.lifecycle.push({ event, invoked });
+    return { event, invoked, status: 200 };
+  }
+
+  return {
+    version: 'pulsewasm.host-runtime-kernel.v2',
+    executeRequest,
+    executeConnect(input) { return executeLifecycle('connect', input || {}); },
+    executeDisconnect(input) { return executeLifecycle('disconnect', input || {}); },
+    close() {},
+    calls,
+    exports: instance.exports,
+    readStringRef,
+    readResult: decodeHostResult
+  };
+}
+
+module.exports = {
+  RESULT_NONE,
+  RESULT_TEXT,
+  RESULT_JSON,
+  RESULT_BINARY,
+  RESULT_EMPTY,
+  RESULT_STREAM,
+  createPulseWasmHostRuntime,
+  normalizeHeaders
+};
+`;
+}
+
+function runtimeSmoke(runtimeModule, wasmPath, wasmHostAbi, deploymentPosture) {
+  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 runtime = runtimeModule.createPulseWasmHostRuntime({
+    wasmPath,
+    wasmHostAbi,
+    deploymentPosture,
+    handlers,
+    broadcaster: { broadcast(channels, ctx) { broadcasterCalls.push({ channels, ctx }); return undefined; } }
+  });
+  const realtime = runtime.executeRequest({ method: 'GET', path: '/realtime/abc', headers: [['X-Pulse-Test', 'edge'], ['X-Pulse-Multi', 'one'], ['x-pulse-multi', 'two']] });
+  const compute = runtime.executeRequest({ method: 'POST', path: '/compute/42', headers: [['X-Pulse-Test', 'edge']] });
+  const missing = runtime.executeRequest({ method: 'GET', path: '/missing' });
+  const connect = runtime.executeConnect({ method: 'GET', path: '/realtime/abc' });
+  const disconnect = runtime.executeDisconnect({ method: 'GET', path: '/realtime/abc' });
+
+  const noBroadcasterRuntime = runtimeModule.createPulseWasmHostRuntime({ wasmPath, wasmHostAbi, deploymentPosture, handlers });
+  const missingBroadcaster = noBroadcasterRuntime.executeRequest({ method: 'GET', path: '/realtime/abc' });
+
+  let missingHandlerRejected = false;
+  let missingHandlerCode;
+  try {
+    const incomplete = { ...handlers };
+    delete incomplete.auth;
+    runtimeModule.createPulseWasmHostRuntime({ wasmPath, wasmHostAbi, deploymentPosture, handlers: incomplete, broadcaster: { broadcast() {} } });
+  } catch (error) {
+    missingHandlerRejected = true;
+    missingHandlerCode = error.code;
+  }
+
+  let jsPostureRejected = false;
+  let jsPostureCode;
+  try {
+    runtimeModule.createPulseWasmHostRuntime({ wasmPath, wasmHostAbi, deploymentPosture: { engine: 'js' }, handlers, broadcaster: { broadcast() {} } });
+  } catch (error) {
+    jsPostureRejected = true;
+    jsPostureCode = error.code;
+  }
+
+  function headerValues(result, name) {
+    const lower = String(name).toLowerCase();
+    return result.headers.filter(([key]) => String(key).toLowerCase() === lower).map(([, value]) => value);
+  }
+
+  const checks = [
+    { name: 'realtime_status', expected: 200, actual: realtime.status },
+    { name: 'realtime_body', expected: 'realtime:abc', actual: realtime.body },
+    { name: 'realtime_kind', expected: 'text', actual: realtime.kind },
+    { name: 'compute_status', expected: 201, actual: compute.status },
+    { name: 'compute_body', expected: 'compute:42', actual: compute.body },
+    { name: 'missing_status', expected: 404, actual: missing.status },
+    { name: 'request_header_first', expected: 'edge', actual: observed.headers.first },
+    { name: 'request_header_multi_count', expected: 2, actual: observed.headers.multiCount },
+    { name: 'request_header_multi_second', expected: 'two', actual: observed.headers.multiSecond },
+    { name: 'repeated_grip_channel_count', expected: 2, actual: headerValues(realtime, 'Grip-Channel').length },
+    { name: 'repeated_grip_channel_second', expected: 'realtime:abc', actual: headerValues(realtime, 'Grip-Channel')[1] },
+    { name: 'broadcaster_present_called', expected: 1, actual: broadcasterCalls.length >= 1 ? 1 : 0 },
+    { name: 'broadcaster_missing_status', expected: 500, actual: missingBroadcaster.status },
+    { name: 'broadcaster_missing_code', expected: 'PULSEWASM_BROADCASTER_MISSING', actual: missingBroadcaster.error && missingBroadcaster.error.code },
+    { name: 'connect_invoked', expected: 1, actual: connect.invoked },
+    { name: 'disconnect_invoked', expected: 1, actual: disconnect.invoked },
+    { name: 'state_map_visible', expected: '1', actual: observed.state.gatewaySawAuth },
+    { name: 'deployment_posture_engine', expected: 'wasm', actual: deploymentPosture.engine || 'wasm' },
+    { name: 'missing_handler_rejected', expected: 1, actual: missingHandlerRejected ? 1 : 0 },
+    { name: 'missing_handler_code', expected: 'PULSEWASM_HOST_RUNTIME_MISSING_HANDLER', actual: missingHandlerCode },
+    { name: 'js_posture_rejected', expected: 1, actual: jsPostureRejected ? 1 : 0 },
+    { name: 'js_posture_code', expected: 'PULSEWASM_HOST_RUNTIME_ENGINE_MISMATCH', actual: jsPostureCode }
+  ].map((check) => ({ ...check, status: check.actual === check.expected ? 'ok' : 'error', message: check.actual === check.expected ? undefined : `Expected ${check.expected}, got ${check.actual}.` }));
+
+  return { checks, results: { realtime, compute, missing, missingBroadcaster, connect, disconnect }, observed, broadcasterCalls, missingHandlerRejected, missingHandlerCode, jsPostureRejected, jsPostureCode, runtimeCalls: runtime.calls };
+}
+
+function buildArtifact(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const checks = options.smoke?.checks || [];
+  const failedChecks = checks.filter((check) => check.status !== 'ok');
+  return normalizeArtifact({
+    version: HOST_RUNTIME_KERNEL_VERSION,
+    generatedBy: options.generatedBy || PACKAGE_VERSION,
+    status: options.diagnostics.length || failedChecks.length ? 'error' : 'ok',
+    sourceWasmHostAbiVersion: options.wasmHostAbi?.version,
+    sourceDeploymentPostureVersion: options.deploymentPosture?.version,
+    policy: {
+      phase: HOST_RUNTIME_KERNEL_PHASE,
+      streamPassThrough: true,
+      responseRefPassthrough: true,
+      sourceOfTruth: 'wasm-host-abi.json + deployment-posture.json + generated Wasm host bridge',
+      platformNeutral: true,
+      streamResults: true,
+      platformAdapters: false,
+      highLevelPulseWrapper: false,
+      listen: false,
+      witBindings: false,
+      wasiHttp: false,
+      ctxFetchEffectRuntime: false,
+      publicApi: ['executeRequest(input)', 'executeConnect(input)', 'executeDisconnect(input)', 'close()'],
+      hostRequestShape: { method: 'string', path: 'string', headers: 'Iterable<[string,string]>', bodyText: 'optional string, deferred' },
+      hostResultShape: { status: 'number', kind: 'text | json | empty', headers: 'Array<[string,string]>', body: 'optional string', error: 'optional structured error' },
+      setupFailuresThrow: true,
+      routingOutcomesReturnHostResult: true
+    },
+    runtimeFile: { file: HOST_RUNTIME_FILE, bytes: Buffer.byteLength(options.runtimeText || '', 'utf8'), sha256: sha256Text(options.runtimeText || '') },
+    wasmInput: options.wasmFile ? fileRecord(options.wasmFile, cwd, 'host-runtime-wasm-input') : undefined,
+    smoke: options.smoke,
+    diagnostics: options.diagnostics,
+    summary: {
+      generated: true,
+      smokeExecuted: Boolean(options.smoke),
+      checks: checks.length,
+      failedChecks: failedChecks.length,
+      platformNeutral: true,
+      streamResults: true,
+      wasmInstantiated: Boolean(options.smoke),
+      requestsExecuted: options.smoke ? 4 : 0,
+      lifecycleExecuted: options.smoke ? 2 : 0,
+      broadcasterPresentValidated: Boolean(options.smoke?.checks?.find((check) => check.name === 'broadcaster_present_called' && check.status === 'ok')),
+      missingBroadcasterValidated: Boolean(options.smoke?.checks?.find((check) => check.name === 'broadcaster_missing_code' && check.status === 'ok')),
+      postureEnforced: Boolean(options.smoke?.checks?.find((check) => check.name === 'js_posture_code' && check.status === 'ok')),
+      missingHandlerSetupFailureValidated: Boolean(options.smoke?.checks?.find((check) => check.name === 'missing_handler_code' && check.status === 'ok')),
+      diagnostics: options.diagnostics.length,
+      platformBindings: false,
+      witBindings: false
+    }
+  }, cwd);
+}
+
+function buildHostRuntimeKernel(wasmHostAbi, wasmHostBridge, deploymentPosture, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const outDir = options.outDir ? path.resolve(cwd, options.outDir) : getDefaultArtifactsDir(cwd);
+  const generatedBy = options.generatedBy || PACKAGE_VERSION;
+  const runtimeText = buildHostRuntimeKernelSource();
+  const diagnostics = [];
+  const wasmFile = path.join(outDir, 'generated/wasm-bridge/pulsewasm-host-bridge.wasm');
+  let smoke;
+
+  if (!wasmHostAbi || !wasmHostAbi.artifact) {
+    diagnostics.push(diagnosticFromParts({ phase: 'host-runtime-kernel', code: 'PULSEWASM_HOST_RUNTIME_ABI_REQUIRED', message: 'Phase 11A requires wasm-host-abi.json.', hint: 'Enable --emit-wasm-host-abi before --emit-host-runtime-kernel.' }));
+  }
+  if (!wasmHostBridge || !wasmHostBridge.artifact) {
+    diagnostics.push(diagnosticFromParts({ phase: 'host-runtime-kernel', code: 'PULSEWASM_HOST_RUNTIME_BRIDGE_REQUIRED', message: 'Phase 11A requires the local Wasm host bridge proof.', hint: 'Enable --emit-wasm-host-bridge before --emit-host-runtime-kernel.' }));
+  }
+  if (!deploymentPosture || !deploymentPosture.artifact) {
+    diagnostics.push(diagnosticFromParts({ phase: 'host-runtime-kernel', code: 'PULSEWASM_HOST_RUNTIME_POSTURE_REQUIRED', message: 'Phase 11A requires deployment-posture.json.', hint: 'Enable --emit-json-body or deployment posture emission before --emit-host-runtime-kernel.' }));
+  }
+  if (!fs.existsSync(wasmFile)) {
+    diagnostics.push(diagnosticFromParts({ phase: 'host-runtime-kernel', code: 'PULSEWASM_HOST_RUNTIME_WASM_NOT_FOUND', message: 'Phase 11A expected the compiled host bridge Wasm file to exist.', hint: 'Run the host bridge build path before generating the host runtime kernel.', details: { wasmFile } }));
+  }
+
+  if (diagnostics.length === 0) {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pulsewasm-host-runtime-'));
+    const tempFile = path.join(tempDir, 'host-runtime-kernel.cjs');
+    fs.writeFileSync(tempFile, runtimeText, 'utf8');
+    try {
+      const runtimeModule = require(tempFile);
+      smoke = runtimeSmoke(runtimeModule, wasmFile, wasmHostAbi.artifact, deploymentPosture.artifact);
+      const failedChecks = smoke.checks.filter((check) => check.status !== 'ok');
+      if (failedChecks.length > 0) {
+        diagnostics.push(diagnosticFromParts({ phase: 'host-runtime-kernel', code: 'PULSEWASM_HOST_RUNTIME_SMOKE_FAILED', message: 'Phase 11A host runtime kernel smoke checks failed.', hint: 'Inspect host-runtime-kernel.json smoke.failedChecks for details.', details: { failedChecks } }));
+      }
+    } catch (error) {
+      diagnostics.push(diagnosticFromParts({ phase: 'host-runtime-kernel', code: 'PULSEWASM_HOST_RUNTIME_EXECUTION_FAILED', message: 'Phase 11A host runtime kernel 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, wasmHostAbi: wasmHostAbi?.artifact, wasmHostBridge: wasmHostBridge?.artifact, deploymentPosture: deploymentPosture?.artifact, runtimeText, wasmFile: fs.existsSync(wasmFile) ? wasmFile : undefined, smoke, diagnostics });
+  return { artifact, files: [{ file: HOST_RUNTIME_FILE, text: runtimeText }], diagnostics };
+}
+
+module.exports = {
+  HOST_RUNTIME_KERNEL_VERSION,
+  buildHostRuntimeKernel,
+  buildHostRuntimeKernelSource
+};