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

package/src/compiler/compiled-wasm-runtime.js

@@ -0,0 +1,612 @@
+'use strict';
+
+const crypto = require('node:crypto');
+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 { spawnSync } = require('node:child_process');
+const { PACKAGE_VERSION, normalizeArtifact, normalizeDiagnostic } = require('@pulse-compute/wasm-contracts/diagnostics');
+const { resolveAsc } = require('@pulse-compute/wasm-build-support/assemblyscript-compile');
+
+const COMPILED_WASM_RUNTIME_VERSION = 'pulsewasm.compiled-wasm-runtime.v1';
+const COMPILED_WASM_HOST_RUNTIME_VERSION = 'pulsewasm.compiled-wasm-host-runtime.v1';
+const COMPILED_WASM_NODE_ADAPTER_VERSION = 'pulsewasm.compiled-wasm-node-adapter.v1';
+const COMPILED_WASM_RUNTIME_SMOKE_VERSION = 'pulsewasm.compiled-wasm-runtime-smoke.v1';
+const PHASE = '12F';
+
+function sha256Text(text) { return crypto.createHash('sha256').update(String(text || ''), 'utf8').digest('hex'); }
+function sha256Buffer(buffer) { return crypto.createHash('sha256').update(buffer).digest('hex'); }
+function makeFile(file, text) { return { file, text, bytes: Buffer.byteLength(text, 'utf8'), sha256: sha256Text(text) }; }
+function stripAnsi(value) { return String(value || '').replace(/\u001b\[[0-9;]*m/g, ''); }
+function truncate(value, max = 12000) { const text = String(value || ''); return text.length > max ? `${text.slice(0, max)}\n...<truncated>` : text; }
+function diagnostic(code, message, hint, details) { return normalizeDiagnostic({ phase: 'compiled-wasm-runtime', severity: 'error', code, message, hint, details, loc: { file: '<compiled-wasm-runtime>' } }); }
+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 parseAscWarnings(stderr) {
+  const text = stripAnsi(stderr);
+  const warnings = [];
+  const regex = /WARNING\s+(AS\d+):\s+([^\n]+)(?:.|\n)*?in ([^\n]+)\((\d+),(\d+)\)/g;
+  let match;
+  while ((match = regex.exec(text))) warnings.push({ code: match[1], message: match[2].trim(), file: match[3], line: Number(match[4]), column: Number(match[5]) });
+  if (warnings.length === 0 && /WARNING\s+AS\d+:/m.test(text)) warnings.push({ code: 'AS_WARNING', message: 'AssemblyScript emitted one or more warnings. Inspect stderr.' });
+  return warnings;
+}
+
+function buildCompiledUserHandlersSource() {
+  return `/* Generated by PulseWasm Phase 12F.
+ * Integrated compiled-Wasm runtime fixture handlers.
+ * Uses schema JSON sidecars, library sidecars, and RESULT_STREAM selection.
+ */
+import {
+  PulseWasmDispatchState,
+  pulse_next,
+  pulse_next_error,
+  pulse_set_result
+} from './runtime-core.as'
+
+import {
+  parse as parse_app_CreateUserBody,
+  ok as ok_app_CreateUserBody,
+  value as value_app_CreateUserBody,
+  error as error_app_CreateUserBody,
+  name as name_app_CreateUserBody,
+  age as age_app_CreateUserBody,
+  active as active_app_CreateUserBody
+} from './schema-json/app/create-user-body.as'
+
+import {
+  pulse_test_mark,
+  pulse_test_last_mark,
+  pulse_test_mark_count
+} from './library-sidecars/test-extension.as'
+
+export const RESULT_NONE: i32 = 0
+export const RESULT_TEXT: i32 = 1
+export const RESULT_JSON: i32 = 2
+export const RESULT_BINARY: i32 = 3
+export const RESULT_EMPTY: i32 = 4
+export const RESULT_STREAM: i32 = 5
+
+let __resultStatus: i32 = 0
+let __resultKind: i32 = RESULT_NONE
+let __resultBody: string = ''
+let __resultResponseRef: usize = 0
+let __resultStreamRef: usize = 0
+let __requestBodyText: string = ''
+let __responseHeaderNames = new Array<string>()
+let __responseHeaderValues = new Array<string>()
+let __responseHeaderModes = new Array<i32>()
+
+function lowerAscii(value: string): string {
+  let out = ''
+  for (let i: i32 = 0; i < value.length; i += 1) {
+    let code = value.charCodeAt(i)
+    if (code >= 65 && code <= 90) code += 32
+    out += String.fromCharCode(code)
+  }
+  return out
+}
+function headerNameEquals(left: string, right: string): bool { return lowerAscii(left) == lowerAscii(right) }
+
+export function integrated_reset(): void {
+  __resultStatus = 0
+  __resultKind = RESULT_NONE
+  __resultBody = ''
+  __resultResponseRef = 0
+  __resultStreamRef = 0
+  __requestBodyText = ''
+  __responseHeaderNames = new Array<string>()
+  __responseHeaderValues = new Array<string>()
+  __responseHeaderModes = new Array<i32>()
+}
+export function integrated_set_body_text(value: string): void { __requestBodyText = value }
+export function integrated_result_status(): i32 { return __resultStatus }
+export function integrated_result_kind(): i32 { return __resultKind }
+export function integrated_result_body(): string { return __resultBody }
+export function integrated_result_response_ref(): usize { return __resultResponseRef }
+export function integrated_result_stream_ref(): usize { return __resultStreamRef }
+export function integrated_response_header_count(): i32 { return __responseHeaderNames.length }
+export function integrated_response_header_name_at(index: i32): string { return index < 0 || index >= __responseHeaderNames.length ? '' : __responseHeaderNames[index] }
+export function integrated_response_header_value_at(index: i32): string { return index < 0 || index >= __responseHeaderValues.length ? '' : __responseHeaderValues[index] }
+export function integrated_response_header_mode_at(index: i32): i32 { return index < 0 || index >= __responseHeaderModes.length ? 2 : __responseHeaderModes[index] }
+export function integrated_response_header_first(name: string): string {
+  for (let i: i32 = 0; i < __responseHeaderNames.length; i += 1) if (headerNameEquals(__responseHeaderNames[i], name)) return __responseHeaderValues[i]
+  return ''
+}
+export function integrated_response_header_count_named(name: string): i32 {
+  let count: i32 = 0
+  for (let i: i32 = 0; i < __responseHeaderNames.length; i += 1) if (headerNameEquals(__responseHeaderNames[i], name)) count += 1
+  return count
+}
+export function integrated_test_mark_count(): i32 { return pulse_test_mark_count() }
+export function integrated_test_last_mark(): string { return pulse_test_last_mark() }
+
+function responseHeaderAppend(name: string, value: string): void { __responseHeaderNames.push(name); __responseHeaderValues.push(value); __responseHeaderModes.push(2) }
+function responseHeaderSet(name: string, value: string): void {
+  const nextNames = new Array<string>()
+  const nextValues = new Array<string>()
+  const nextModes = new Array<i32>()
+  for (let i: i32 = 0; i < __responseHeaderNames.length; i += 1) {
+    if (!headerNameEquals(__responseHeaderNames[i], name)) { nextNames.push(__responseHeaderNames[i]); nextValues.push(__responseHeaderValues[i]); nextModes.push(__responseHeaderModes[i]) }
+  }
+  __responseHeaderNames = nextNames
+  __responseHeaderValues = nextValues
+  __responseHeaderModes = nextModes
+  __responseHeaderNames.push(name)
+  __responseHeaderValues.push(value)
+  __responseHeaderModes.push(1)
+}
+function setTextResult(ctx: usize, status: i32, body: string): void {
+  __resultStatus = status
+  __resultKind = RESULT_TEXT
+  __resultBody = body
+  pulse_set_result(changetype<PulseWasmDispatchState>(ctx), 1)
+}
+function setJsonTextResult(ctx: usize, status: i32, body: string): void {
+  responseHeaderSet('Content-Type', 'application/json')
+  __resultStatus = status
+  __resultKind = RESULT_JSON
+  __resultBody = body
+  pulse_set_result(changetype<PulseWasmDispatchState>(ctx), 1)
+}
+function setStreamFromResponse(ctx: usize, responseRef: usize): void {
+  __resultStatus = 0
+  __resultKind = RESULT_STREAM
+  __resultResponseRef = responseRef
+  __resultStreamRef = 0
+  __resultBody = ''
+  pulse_set_result(changetype<PulseWasmDispatchState>(ctx), 1)
+}
+
+export function testExtension(ctx: usize, next: usize): void { pulse_next(changetype<PulseWasmDispatchState>(ctx)) }
+
+export function createUser(ctx: usize, next: usize): void {
+  const parsed = parse_app_CreateUserBody(__requestBodyText)
+  if (!ok_app_CreateUserBody(parsed)) {
+    pulse_next_error(changetype<PulseWasmDispatchState>(ctx), error_app_CreateUserBody(parsed))
+    return
+  }
+  const body = value_app_CreateUserBody(parsed)
+  setJsonTextResult(ctx, 201, '{"name":"' + name_app_CreateUserBody(body) + '","age":' + age_app_CreateUserBody(body).toString() + ',"active":' + (active_app_CreateUserBody(body) ? 'true' : 'false') + '}')
+}
+
+export function testExtensionRoute(ctx: usize, next: usize): void {
+  pulse_test_mark(ctx, 'ok')
+  responseHeaderAppend('Grip-Channel', 'fixture')
+  setTextResult(ctx, 220, 'extension:' + pulse_test_last_mark())
+}
+
+export function streamRoute(ctx: usize, next: usize): void {
+  responseHeaderSet('Cache-Control', 'public, max-age=120')
+  responseHeaderAppend('Grip-Channel', 'stream:fixture')
+  setStreamFromResponse(ctx, 77)
+}
+
+export function handleError(err: usize, ctx: usize, next: usize): void {
+  setTextResult(ctx, 400, 'schema-error')
+}
+`;
+}
+
+function buildCompiledHandlerSlotsSource(dispatchTable) {
+  const slots = (dispatchTable?.handlerSlots || []).slice().sort((a, b) => Number(a.slot) - Number(b.slot));
+  const imports = slots.map((slot) => slot.exportName || slot.name).filter(Boolean);
+  const uniqueImports = Array.from(new Set(imports));
+  const cases = { route: [], middleware: [], lifecycle: [], error: [], channel: [] };
+  for (const slot of slots) {
+    const role = String((slot.roles || [])[0] || '').split(':')[0];
+    const name = slot.exportName || slot.name;
+    const slotNum = Number(slot.slot) | 0;
+    if (!name) continue;
+    if (role === 'route') cases.route.push(`    case ${slotNum}: ${name}(ctx, next); return true`);
+    else if (role === 'middleware') cases.middleware.push(`    case ${slotNum}: ${name}(ctx, next); return true`);
+    else if (role === 'lifecycle') cases.lifecycle.push(`    case ${slotNum}: ${name}(ctx, next); return true`);
+    else if (role === 'error') cases.error.push(`    case ${slotNum}: ${name}(err, ctx, next); return true`);
+    else if (role === 'channel') cases.channel.push(`    case ${slotNum}: return ${name}(ctx)`);
+  }
+  return `/* Generated by PulseWasm Phase 12F. Compiled-wasm handler slots. */
+import { ROLE_ROUTE, ROLE_MIDDLEWARE, ROLE_LIFECYCLE, ROLE_ERROR, ROLE_CHANNEL } from './types.as'
+import { HANDLER_SLOT_COUNT, HANDLER_ROLE_CODES, HANDLER_SLOT_NAMES } from './route-table.as'
+import { ${uniqueImports.join(', ')} } from './user-handlers.as'
+
+export const HANDLER_BINDING_COUNT: i32 = HANDLER_SLOT_COUNT
+export function handlerSlotName(slot: i32): string { return slot < 0 || slot >= HANDLER_SLOT_NAMES.length ? '' : HANDLER_SLOT_NAMES[slot] }
+export function handlerSlotPrimaryRole(slot: i32): i32 { return slot < 0 || slot >= HANDLER_ROLE_CODES.length ? 0 : HANDLER_ROLE_CODES[slot] }
+export function slotAcceptsRole(slot: i32, roleCode: i32): bool { return handlerSlotPrimaryRole(slot) == roleCode }
+export function invokeRouteHandlerBySlot(slot: i32, ctx: usize, next: usize): bool { if (!slotAcceptsRole(slot, ROLE_ROUTE)) return false; switch (slot) {
+${cases.route.join('\n')}
+    default: return false
+  } }
+export function invokeMiddlewareHandlerBySlot(slot: i32, ctx: usize, next: usize): bool { if (!slotAcceptsRole(slot, ROLE_MIDDLEWARE)) return false; switch (slot) {
+${cases.middleware.join('\n')}
+    default: return false
+  } }
+export function invokeLifecycleHandlerBySlot(slot: i32, ctx: usize, next: usize): bool { if (!slotAcceptsRole(slot, ROLE_LIFECYCLE)) return false; switch (slot) {
+${cases.lifecycle.join('\n')}
+    default: return false
+  } }
+export function invokeErrorHandlerBySlot(slot: i32, err: usize, ctx: usize, next: usize): bool { if (!slotAcceptsRole(slot, ROLE_ERROR)) return false; switch (slot) {
+${cases.error.join('\n')}
+    default: return false
+  } }
+export function invokeChannelHandlerBySlot(slot: i32, ctx: usize): usize { if (!slotAcceptsRole(slot, ROLE_CHANNEL)) return 0; switch (slot) {
+${cases.channel.join('\n')}
+    default: return 0
+  } }
+export function invokeHandlerByRole(roleCode: i32, slot: i32, err: usize, ctx: usize, next: usize): bool {
+  if (roleCode == ROLE_ROUTE) return invokeRouteHandlerBySlot(slot, ctx, next)
+  if (roleCode == ROLE_MIDDLEWARE) return invokeMiddlewareHandlerBySlot(slot, ctx, next)
+  if (roleCode == ROLE_LIFECYCLE) return invokeLifecycleHandlerBySlot(slot, ctx, next)
+  if (roleCode == ROLE_ERROR) return invokeErrorHandlerBySlot(slot, err, ctx, next)
+  if (roleCode == ROLE_CHANNEL) return invokeChannelHandlerBySlot(slot, ctx) != 0
+  return false
+}
+`;
+}
+
+function buildCompiledHostBridgeRunnerSource() {
+  return `/* Generated by PulseWasm Phase 12F.
+ * Host-ABI-compatible runner for compiled-wasm handlers.
+ */
+import { METHOD_GET, METHOD_POST } from '../as/types.as'
+import {
+  PulseWasmDispatchState,
+  createDispatchState,
+  stepDispatchState,
+  invokeCurrentHandler,
+  defaultStatusForStepResult,
+  STEP_INVOKE
+} from '../as/runtime-core.as'
+import {
+  integrated_reset,
+  integrated_set_body_text,
+  integrated_result_status,
+  integrated_result_kind,
+  integrated_result_body,
+  integrated_result_response_ref,
+  integrated_result_stream_ref,
+  integrated_response_header_count,
+  integrated_response_header_name_at,
+  integrated_response_header_value_at,
+  integrated_response_header_mode_at
+} from '../as/user-handlers.as'
+
+export const RESULT_NONE: i32 = 0
+export const RESULT_TEXT: i32 = 1
+export const RESULT_JSON: i32 = 2
+export const RESULT_BINARY: i32 = 3
+export const RESULT_EMPTY: i32 = 4
+export const RESULT_STREAM: i32 = 5
+
+let __lastStringBuffer: ArrayBuffer | null = null
+let __requestBodyText: string = ''
+
+function decodeUtf8(ptr: usize, len: i32): string {
+  if (ptr == 0 || len <= 0) return ''
+  return String.UTF8.decodeUnsafe(ptr, len, true)
+}
+function stringPtr(value: string): i32 {
+  const encoded = String.UTF8.encode(value, true)
+  __lastStringBuffer = encoded
+  return changetype<i32>(encoded)
+}
+
+export function pulse_alloc(byteLength: i32): i32 {
+  if (byteLength <= 0) return 0
+  const buffer = new ArrayBuffer(byteLength)
+  return changetype<i32>(buffer)
+}
+export function pulse_free(ptr: i32, byteLength: i32): void {}
+export function pulse_init(): void { pulse_reset() }
+export function pulse_reset(): void { integrated_reset(); __requestBodyText = '' }
+export function pulse_bridge_method_get(): i32 { return METHOD_GET }
+export function pulse_bridge_method_post(): i32 { return METHOD_POST }
+export function pulse_bridge_set_body_text(ptr: i32, len: i32): void { __requestBodyText = decodeUtf8(ptr as usize, len) }
+
+export function pulse_execute_request(methodCode: i32, pathPtr: i32, pathLen: i32): i32 {
+  integrated_reset()
+  integrated_set_body_text(__requestBodyText)
+  const state = createDispatchState(methodCode, decodeUtf8(pathPtr as usize, pathLen))
+  let guard: i32 = 0
+  while (guard < 128) {
+    guard += 1
+    const step = stepDispatchState(state)
+    if (step != STEP_INVOKE) return defaultStatusForStepResult(step)
+    invokeCurrentHandler(state)
+    if (integrated_result_status() != 0 || integrated_result_kind() == RESULT_STREAM) return integrated_result_status() == 0 ? 206 : integrated_result_status()
+  }
+  return 500
+}
+export function pulse_execute_connect(methodCode: i32, pathPtr: i32, pathLen: i32): i32 { return 0 }
+export function pulse_execute_disconnect(methodCode: i32, pathPtr: i32, pathLen: i32): i32 { return 0 }
+
+export function pulse_result_status(): i32 { return integrated_result_status() }
+export function pulse_result_kind(): i32 { return integrated_result_kind() }
+export function pulse_result_body_ptr(): i32 { return stringPtr(integrated_result_body()) }
+export function pulse_result_body_len(): i32 { return String.UTF8.byteLength(integrated_result_body()) }
+export function pulse_result_stream_ref(): i32 { return integrated_result_stream_ref() as i32 }
+export function pulse_result_response_ref(): i32 { return integrated_result_response_ref() as i32 }
+export function pulse_result_header_count(): i32 { return integrated_response_header_count() }
+export function pulse_result_header_name_ptr(index: i32): i32 { return stringPtr(integrated_response_header_name_at(index)) }
+export function pulse_result_header_name_len(index: i32): i32 { return String.UTF8.byteLength(integrated_response_header_name_at(index)) }
+export function pulse_result_header_value_ptr(index: i32): i32 { return stringPtr(integrated_response_header_value_at(index)) }
+export function pulse_result_header_value_len(index: i32): i32 { return String.UTF8.byteLength(integrated_response_header_value_at(index)) }
+export function pulse_result_header_mode(index: i32): i32 { return integrated_response_header_mode_at(index) }
+export function pulse_result_header_delete_count(): i32 { return 0 }
+export function pulse_result_error_ref(): i32 { return 0 }
+
+export function __pulsewasm_abort(message: string | null, fileName: string | null, line: u32, column: u32): void {
+  unreachable()
+}
+`;
+}
+
+function buildCompiledHostRuntimeSource() {
+  return `/* Generated by PulseWasm Phase 12F.
+ * Platform-neutral host runtime for compiled-wasm handler mode.
+ */
+'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;
+
+function createSetupError(code, message, details) { const err = new Error(message); err.code = code; err.details = details; return err; }
+function normalizeHeaders(headers) { if (!headers) return []; if (Array.isArray(headers)) return headers.map((pair) => [String(pair[0]), String(pair[1])]); 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 createPulseWasmCompiledHostRuntime(options = {}) {
+  const wasmBytes = options.wasmBytes || (options.wasmPath ? fs.readFileSync(path.resolve(options.wasmPath)) : undefined);
+  if (!wasmBytes) throw createSetupError('PULSEWASM_COMPILED_RUNTIME_WASM_REQUIRED', 'createPulseWasmCompiledHostRuntime requires wasmBytes or wasmPath.');
+  const deploymentPosture = options.deploymentPosture || { engine: 'wasm' };
+  if ((deploymentPosture.engine || 'wasm') === 'js' && !options.allowJsEngine) throw createSetupError('PULSEWASM_COMPILED_RUNTIME_ENGINE_MISMATCH', 'compiled-wasm host runtime refuses JS engine posture.', { engine: deploymentPosture.engine });
+  if (options.handlers && (options.handlers instanceof Map ? options.handlers.size > 0 : Object.keys(options.handlers).length > 0)) throw createSetupError('PULSEWASM_COMPILED_RUNTIME_HANDLER_REGISTRY_FORBIDDEN', 'compiled-wasm handler mode must not receive JS user handlers.');
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  const module = new WebAssembly.Module(wasmBytes);
+  const imports = { env: { abort() { throw new Error('AssemblyScript abort'); } } };
+  const instance = new WebAssembly.Instance(module, imports);
+  const exports = instance.exports;
+  const hostResponses = new Map();
+  for (const [key, value] of Object.entries(options.hostResponses || {})) hostResponses.set(Number(key), value);
+  if (!hostResponses.has(77)) hostResponses.set(77, { status: 206, headers: [['Content-Type', 'application/octet-stream'], ['Grip-Channel', 'backend:stream']], bodyStream: { chunks: ['asset:42'] } });
+  function memory() { return exports.memory; }
+  function allocText(text) { const bytes = encoder.encode(String(text ?? '')); const ptr = exports.pulse_alloc(bytes.length || 1); new Uint8Array(memory().buffer, ptr, bytes.length).set(bytes); return { ptr, len: bytes.length }; }
+  function readBytes(ptr, len) { if (!ptr || !len) return ''; return decoder.decode(new Uint8Array(memory().buffer, ptr, len)); }
+  function readResultHeaders() { const headers = []; const count = exports.pulse_result_header_count ? exports.pulse_result_header_count() : 0; for (let i = 0; i < count; i += 1) headers.push([readBytes(exports.pulse_result_header_name_ptr(i), exports.pulse_result_header_name_len(i)), readBytes(exports.pulse_result_header_value_ptr(i), exports.pulse_result_header_value_len(i)), exports.pulse_result_header_mode ? exports.pulse_result_header_mode(i) : 2]); return headers; }
+  function mergeHeaders(base, resultHeaders) { const merged = normalizeHeaders(base); 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 decodeResult(status) { const kindCode = exports.pulse_result_kind ? exports.pulse_result_kind() : RESULT_NONE; const resultStatus = exports.pulse_result_status ? exports.pulse_result_status() : status; const resultHeaders = readResultHeaders(); if (kindCode === RESULT_STREAM) { const responseRef = exports.pulse_result_response_ref ? exports.pulse_result_response_ref() : 0; const streamRef = exports.pulse_result_stream_ref ? exports.pulse_result_stream_ref() : 0; const response = hostResponses.get(responseRef) || (streamRef ? { status: resultStatus || status, headers: [], bodyStream: hostResponses.get(streamRef) } : undefined); return { status: resultStatus || (response && response.status) || status, kind: 'stream', kindCode, headers: mergeHeaders(response && response.headers, resultHeaders), bodyStream: response && response.bodyStream, responseRef, streamRef, response, diagnostics: [] }; } const body = exports.pulse_result_body_ptr ? readBytes(exports.pulse_result_body_ptr(), exports.pulse_result_body_len()) : ''; const kind = kindCode === RESULT_JSON ? 'json' : kindCode === RESULT_TEXT ? 'text' : kindCode === RESULT_EMPTY ? 'empty' : 'none'; return { status: resultStatus || status, kind, kindCode, headers: resultHeaders.map(([name, value]) => [name, value]), body: body || undefined, diagnostics: [] }; }
+  function executeRequest(input = {}) { const body = allocText(input.bodyText || ''); if (exports.pulse_bridge_set_body_text) exports.pulse_bridge_set_body_text(body.ptr, body.len); const path = allocText(input.path || '/'); const status = exports.pulse_execute_request(methodNameToCode(exports, input.method), path.ptr, path.len); return decodeResult(status); }
+  return { version: 'pulsewasm.compiled-wasm-host-runtime.v1', handlerExecutionMode: 'compiled-wasm', executeRequest, executeConnect() { return { event: 'connect', invoked: 0, status: 200 }; }, executeDisconnect() { return { event: 'disconnect', invoked: 0, status: 200 }; }, close() {}, exports, imports: WebAssembly.Module.imports(module), hostResponses };
+}
+module.exports = { createPulseWasmCompiledHostRuntime, RESULT_NONE, RESULT_TEXT, RESULT_JSON, RESULT_BINARY, RESULT_EMPTY, RESULT_STREAM };
+`;
+}
+
+function buildCompiledNodeAdapterSource() {
+  return `/* Generated by PulseWasm Phase 12F. Node adapter for compiled-wasm host runtime. */
+'use strict';
+const http = require('node:http');
+const { createPulseWasmCompiledHostRuntime } = require('../host/compiled-wasm-host-runtime.cjs');
+function normalizeRawHeaders(rawHeaders) { if (!Array.isArray(rawHeaders)) return []; const pairs = []; for (let i = 0; i < rawHeaders.length; i += 2) if (rawHeaders[i] !== undefined && rawHeaders[i + 1] !== undefined) pairs.push([String(rawHeaders[i]), String(rawHeaders[i + 1])]); return pairs; }
+function normalizeNodeHeaders(req) { if (Array.isArray(req && req.rawHeaders) && req.rawHeaders.length > 0) return normalizeRawHeaders(req.rawHeaders); const headers = req && req.headers ? req.headers : {}; const pairs = []; for (const [name, value] of Object.entries(headers)) Array.isArray(value) ? value.forEach((v) => pairs.push([name, String(v)])) : pairs.push([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, extra = {}) { return { method: String((req && req.method) || 'GET').toUpperCase(), path: normalizeNodePath(req), headers: normalizeNodeHeaders(req), bodyText: extra.bodyText }; }
+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; } } res.end(result.body === undefined || result.body === null ? '' : String(result.body)); return result; }
+function createNodeHandler(runtime, options = {}) { if (!runtime || typeof runtime.executeRequest !== 'function') throw new Error('createNodeHandler requires a compiled PulseWasm host runtime.'); return function compiledPulseWasmNodeHandler(req, res) { const result = runtime.executeRequest(nodeRequestToHostRequest(req, options)); 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 createPulseWasmCompiledNodeAdapter(options = {}) { const runtime = options.runtime || createPulseWasmCompiledHostRuntime(options); return { version: 'pulsewasm.compiled-wasm-node-adapter.v1', 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(); } }; }
+module.exports = { createPulseWasmCompiledNodeAdapter, createNodeHandler, createNodeServer, nodeRequestToHostRequest, normalizeNodeHeaders, normalizeRawHeaders, normalizeNodePath, writeNodeResponse, groupHeaders };
+`;
+}
+
+function writeStagedFiles(stagingDir, shape, core, schemaJsonSidecar, librarySidecars, files) {
+  const byFile = new Map();
+  for (const file of (shape?.files || [])) byFile.set(file.file, file.text);
+  for (const file of (core?.files || [])) byFile.set(file.file, file.text);
+  for (const file of (schemaJsonSidecar?.files || [])) if (file.file.startsWith('generated/as/schema-json/')) byFile.set(file.file, file.text);
+  for (const file of (librarySidecars?.files || [])) if (file.file.startsWith('generated/as/library-sidecars/')) byFile.set(file.file, file.text);
+  for (const file of files) byFile.set(file.file, file.text);
+  for (const [file, text] of byFile.entries()) {
+    const abs = path.join(stagingDir, file);
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, text, 'utf8');
+  }
+  return Array.from(byFile.entries()).map(([file, text]) => ({ file, bytes: Buffer.byteLength(text, 'utf8'), sha256: sha256Text(text) }));
+}
+
+function compileWasm({ cwd, outDir, shape, core, schemaJsonSidecar, librarySidecars, files }) {
+  const diagnostics = [];
+  const asc = resolveAsc(cwd);
+  if (!asc) {
+    diagnostics.push(diagnostic('PULSEWASM_COMPILED_RUNTIME_ASC_MISSING', 'AssemblyScript compiler dependency was not found.', 'Run npm install before the compiled-wasm runtime smoke.'));
+    return { diagnostics, warnings: [], outputFiles: [] };
+  }
+  const stagingDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pulsewasm-compiled-runtime-'));
+  const outputDir = path.join(outDir || getDefaultArtifactsDir(cwd), 'generated', 'compiled-wasm-runtime');
+  fs.mkdirSync(outputDir, { recursive: true });
+  const staged = writeStagedFiles(stagingDir, shape, core, schemaJsonSidecar, librarySidecars, files);
+  const wasmFile = path.join(outputDir, 'pulsewasm-compiled-runtime.wasm');
+  const entry = 'generated/host-bridge/compiled-host-bridge-runner.as.ts';
+  const abortOverride = 'generated/host-bridge/compiled-host-bridge-runner.as/__pulsewasm_abort';
+  const ascArgs = [asc.script, entry, '--outFile', wasmFile, '--runtime', 'stub', '--noAssert', '--use', `abort=${abortOverride}`];
+  const proc = spawnSync(asc.executable, ascArgs, { cwd: stagingDir, encoding: 'utf8', maxBuffer: 1024 * 1024 * 16 });
+  const warnings = parseAscWarnings(proc.stderr);
+  if (proc.error || proc.status !== 0) diagnostics.push(diagnostic('PULSEWASM_COMPILED_RUNTIME_AS_COMPILE_FAILED', `Compiled-wasm runtime AssemblyScript smoke failed${proc.status !== undefined ? ` with exit code ${proc.status}` : ''}.`, 'Inspect compiled-wasm-runtime-smoke.json stderr/stdout.', { stdout: truncate(proc.stdout), stderr: truncate(proc.stderr), exitCode: proc.status }));
+  const outputFiles = [];
+  if (fs.existsSync(wasmFile)) outputFiles.push(fileRecord(wasmFile, cwd, 'compiled-wasm-runtime-wasm'));
+  return { diagnostics, warnings, outputFiles, wasmFile, staged, command: { executable: asc.display, args: ascArgs.slice(1).map((arg) => path.isAbsolute(arg) ? path.relative(cwd, arg).replace(/\\/g, '/') : arg) }, result: { exitCode: proc.status, stdout: truncate(proc.stdout), stderr: truncate(proc.stderr) } };
+}
+
+function loadGeneratedModule(filePath) {
+  delete require.cache[require.resolve(filePath)];
+  return require(filePath);
+}
+
+function makeMockResponse() {
+  const headers = [];
+  return {
+    statusCode: 0,
+    body: undefined,
+    setHeader(name, value) { Array.isArray(value) ? value.forEach((item) => headers.push([String(name), String(item)])) : 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 runHostSmoke({ runtimeModule, nodeModule, wasmFile }) {
+  const checks = [];
+  function check(name, expected, actual) { checks.push({ name, expected, actual, status: Object.is(expected, actual) ? 'ok' : 'error', message: Object.is(expected, actual) ? undefined : `Expected ${expected}, got ${actual}.` }); }
+  let setupMissingHandlerRejected = false;
+  let setupHandlerRegistryRejected = false;
+  let setupJsPostureRejected = false;
+  try { runtimeModule.createPulseWasmCompiledHostRuntime({ wasmPath: wasmFile, handlers: { auth() {} } }); } catch (error) { setupHandlerRegistryRejected = error.code === 'PULSEWASM_COMPILED_RUNTIME_HANDLER_REGISTRY_FORBIDDEN'; }
+  try { runtimeModule.createPulseWasmCompiledHostRuntime({ wasmPath: wasmFile, deploymentPosture: { engine: 'js' } }); } catch (error) { setupJsPostureRejected = error.code === 'PULSEWASM_COMPILED_RUNTIME_ENGINE_MISMATCH'; }
+  try { runtimeModule.createPulseWasmCompiledHostRuntime({}); } catch (error) { setupMissingHandlerRejected = error.code === 'PULSEWASM_COMPILED_RUNTIME_WASM_REQUIRED'; }
+  const runtime = runtimeModule.createPulseWasmCompiledHostRuntime({ wasmPath: wasmFile, deploymentPosture: { engine: 'wasm' }, hostResponses: { 77: { status: 206, headers: [['Content-Type', 'application/octet-stream'], ['Grip-Channel', 'backend:stream'], ['Server', 'origin']], bodyStream: { chunks: ['asset:42'] } } } });
+  const schemaOk = runtime.executeRequest({ method: 'POST', path: '/users', bodyText: '{"name":"Ada","age":42,"active":true}' });
+  const schemaFail = runtime.executeRequest({ method: 'POST', path: '/users', bodyText: '{"name":42,"age":42,"active":true}' });
+  const extension = runtime.executeRequest({ method: 'GET', path: '/extension' });
+  const stream = runtime.executeRequest({ method: 'GET', path: '/stream' });
+  const missing = runtime.executeRequest({ method: 'GET', path: '/missing' });
+  const imports = runtime.imports || [];
+  check('schema_success_status', 201, schemaOk.status);
+  check('schema_success_kind', 'json', schemaOk.kind);
+  check('schema_success_body', '{"name":"Ada","age":42,"active":true}', schemaOk.body);
+  check('schema_success_content_type', 'application/json', (schemaOk.headers.find(([name]) => String(name).toLowerCase() === 'content-type') || [])[1]);
+  check('schema_failure_status', 400, schemaFail.status);
+  check('schema_failure_body', 'schema-error', schemaFail.body);
+  check('extension_status', 220, extension.status);
+  check('extension_body', 'extension:ok', extension.body);
+  check('extension_grip_header', 'fixture', (extension.headers.find(([name]) => String(name).toLowerCase() === 'grip-channel') || [])[1]);
+  check('stream_status', 206, stream.status);
+  check('stream_kind', 'stream', stream.kind);
+  check('stream_response_ref', 77, stream.responseRef);
+  check('stream_body_chunk', 'asset:42', stream.bodyStream && stream.bodyStream.chunks && stream.bodyStream.chunks[0]);
+  check('stream_cache_control_override', 'public, max-age=120', (stream.headers.find(([name]) => String(name).toLowerCase() === 'cache-control') || [])[1]);
+  check('stream_backend_header_preserved', 'application/octet-stream', (stream.headers.find(([name]) => String(name).toLowerCase() === 'content-type') || [])[1]);
+  check('stream_repeated_grip_count', 2, stream.headers.filter(([name]) => String(name).toLowerCase() === 'grip-channel').length);
+  check('missing_status', 404, missing.status);
+  check('no_js_handler_import_module', 0, imports.filter((item) => item.module === 'pulsewasm_handlers').length);
+  check('handler_registry_rejected', true, setupHandlerRegistryRejected);
+  check('js_posture_rejected', true, setupJsPostureRejected);
+  check('missing_wasm_rejected', true, setupMissingHandlerRejected);
+  const adapter = nodeModule.createPulseWasmCompiledNodeAdapter({ runtime });
+  const req = { method: 'GET', url: '/stream', rawHeaders: ['X-Test', 'one'] };
+  const res = makeMockResponse();
+  const nodeResult = adapter.handleNodeRequest(req, res);
+  check('node_adapter_status', 206, res.statusCode);
+  check('node_adapter_stream_body', 'asset:42', res.body);
+  check('node_adapter_repeated_grip_count', 2, res.headers.filter(([name]) => String(name).toLowerCase() === 'grip-channel').length);
+  check('node_adapter_kind', 'stream', nodeResult.kind);
+  return { checks, failedChecks: checks.filter((item) => item.status !== 'ok'), results: { schemaOk, schemaFail, extension, stream, missing, nodeResult }, imports };
+}
+
+function buildMarkdown(artifact) {
+  const lines = ['# PulseWasm Phase 12F — Local Wasm Runtime with Compiled Handlers', '', '## Status', artifact.status === 'ok' ? 'Implemented.' : 'Generated with errors.', '', '## Scope'];
+  for (const item of artifact.scope) lines.push(`- ${item}`);
+  lines.push('', '## Reserved');
+  for (const item of artifact.reserved) lines.push(`- ${item}`);
+  return `${lines.join('\n')}\n`;
+}
+
+function buildCompiledWasmRuntime({ assemblyScriptShape, assemblyScriptCore, schemaJsonSidecar, librarySidecars } = {}, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const outDir = options.outDir || getDefaultArtifactsDir(cwd);
+  const generatedBy = options.generatedBy || PACKAGE_VERSION;
+  const diagnostics = [];
+  if (!assemblyScriptShape?.files) diagnostics.push(diagnostic('PULSEWASM_COMPILED_RUNTIME_AS_SHAPE_REQUIRED', 'Phase 12F requires AssemblyScript shape files.', 'Enable --emit-assemblyscript-shape.'));
+  if (!assemblyScriptCore?.files) diagnostics.push(diagnostic('PULSEWASM_COMPILED_RUNTIME_AS_CORE_REQUIRED', 'Phase 12F requires AssemblyScript core files.', 'Enable --emit-assemblyscript-core.'));
+  if (!schemaJsonSidecar?.files) diagnostics.push(diagnostic('PULSEWASM_COMPILED_RUNTIME_SCHEMA_SIDECAR_REQUIRED', 'Phase 12F requires schema JSON sidecar files.', 'Enable --emit-schema-json-sidecar.'));
+  if (!librarySidecars?.files) diagnostics.push(diagnostic('PULSEWASM_COMPILED_RUNTIME_LIBRARY_SIDECAR_REQUIRED', 'Phase 12F requires library sidecar files.', 'Enable --emit-library-sidecars.'));
+  const runtimeText = buildCompiledHostRuntimeSource();
+  const nodeText = buildCompiledNodeAdapterSource();
+  const files = [
+    makeFile('generated/as/user-handlers.as.ts', buildCompiledUserHandlersSource()),
+    makeFile('generated/as/handler-slots.as.ts', buildCompiledHandlerSlotsSource(options.dispatchTable)),
+    makeFile('generated/host-bridge/compiled-host-bridge-runner.as.ts', buildCompiledHostBridgeRunnerSource()),
+    makeFile('generated/host/compiled-wasm-host-runtime.cjs', runtimeText),
+    makeFile('generated/node/compiled-wasm-node-adapter.cjs', nodeText),
+    makeFile('generated/host/compiled-wasm-runtime.md', '')
+  ];
+  let compile = { diagnostics: [], warnings: [], outputFiles: [] };
+  if (diagnostics.length === 0) compile = compileWasm({ cwd, outDir, shape: assemblyScriptShape, core: assemblyScriptCore, schemaJsonSidecar, librarySidecars, files });
+  diagnostics.push(...(compile.diagnostics || []));
+  const runtimeFile = path.join(outDir, 'generated/host/compiled-wasm-host-runtime.cjs');
+  const nodeFile = path.join(outDir, 'generated/node/compiled-wasm-node-adapter.cjs');
+  fs.mkdirSync(path.dirname(runtimeFile), { recursive: true });
+  fs.writeFileSync(runtimeFile, runtimeText, 'utf8');
+  fs.mkdirSync(path.dirname(nodeFile), { recursive: true });
+  fs.writeFileSync(nodeFile, nodeText, 'utf8');
+  let smokeResult;
+  if (diagnostics.length === 0 && compile.wasmFile && fs.existsSync(compile.wasmFile)) {
+    try {
+      smokeResult = runHostSmoke({ runtimeModule: loadGeneratedModule(runtimeFile), nodeModule: loadGeneratedModule(nodeFile), wasmFile: compile.wasmFile });
+      if (smokeResult.failedChecks.length) diagnostics.push(diagnostic('PULSEWASM_COMPILED_RUNTIME_SMOKE_FAILED', 'Compiled-wasm runtime smoke checks failed.', 'Inspect compiled-wasm-runtime-smoke.json.', { failedChecks: smokeResult.failedChecks }));
+    } catch (error) {
+      diagnostics.push(diagnostic('PULSEWASM_COMPILED_RUNTIME_SMOKE_EXECUTION_FAILED', 'Compiled-wasm runtime smoke execution failed.', undefined, { message: error && error.message ? error.message : String(error), stack: error && error.stack ? error.stack : undefined }));
+    }
+  }
+  const smoke = normalizeArtifact({
+    version: COMPILED_WASM_RUNTIME_SMOKE_VERSION,
+    generatedBy,
+    phase: PHASE,
+    status: diagnostics.length ? 'error' : 'ok',
+    command: compile.command,
+    result: compile.result,
+    generated: { inputFiles: compile.staged || [], outputFiles: compile.outputFiles || [] },
+    checks: smokeResult?.checks || [],
+    failedChecks: smokeResult?.failedChecks || [],
+    imports: smokeResult?.imports || [],
+    warnings: compile.warnings || [],
+    diagnostics,
+    summary: { compiled: Boolean(compile.outputFiles?.length) && diagnostics.length === 0, executed: Boolean(smokeResult), checks: smokeResult?.checks?.length || 0, failedChecks: smokeResult?.failedChecks?.length || 0, jsHandlerImports: (smokeResult?.imports || []).filter((item) => item.module === 'pulsewasm_handlers').length, nodeAdapterStreamForwarding: Boolean(smokeResult?.checks?.some((check) => check.name === 'node_adapter_stream_body' && check.status === 'ok')), diagnostics: diagnostics.length, warnings: (compile.warnings || []).length }
+  }, cwd);
+  const hostRuntime = normalizeArtifact({
+    version: COMPILED_WASM_HOST_RUNTIME_VERSION,
+    generatedBy,
+    phase: PHASE,
+    status: diagnostics.length ? 'error' : 'ok',
+    handlerExecutionMode: 'compiled-wasm',
+    sourceOfTruth: 'compiled-handler Wasm + host ABI result decoding',
+    jsHandlerRegistryRequired: false,
+    jsHandlerRegistryForbidden: true,
+    publicApi: ['executeRequest(input)', 'executeConnect(input)', 'executeDisconnect(input)', 'close()'],
+    runtimeFile: { file: 'generated/host/compiled-wasm-host-runtime.cjs', bytes: Buffer.byteLength(runtimeText, 'utf8'), sha256: sha256Text(runtimeText) },
+    summary: { generated: true, handlerExecutionMode: 'compiled-wasm', noJsHandlerRegistry: true, smokeExecuted: smoke.summary.executed, failedChecks: smoke.summary.failedChecks, diagnostics: diagnostics.length }
+  }, cwd);
+  const nodeAdapter = normalizeArtifact({
+    version: COMPILED_WASM_NODE_ADAPTER_VERSION,
+    generatedBy,
+    phase: PHASE,
+    status: diagnostics.length ? 'error' : 'ok',
+    consumes: COMPILED_WASM_HOST_RUNTIME_VERSION,
+    nodeAdapterFile: { file: 'generated/node/compiled-wasm-node-adapter.cjs', bytes: Buffer.byteLength(nodeText, 'utf8'), sha256: sha256Text(nodeText) },
+    summary: { generated: true, streamForwardingValidated: smoke.summary.nodeAdapterStreamForwarding, diagnostics: diagnostics.length }
+  }, cwd);
+  const artifact = normalizeArtifact({
+    version: COMPILED_WASM_RUNTIME_VERSION,
+    generatedBy,
+    phase: PHASE,
+    status: diagnostics.length ? 'error' : 'ok',
+    policy: { integrationOnly: false, handlerExecutionMode: 'compiled-wasm', hostRuntimeDriven: true, nodeAdapterDriven: true, jsUserHandlerImports: false, jsHandlerRegistryRequired: false, platformAdapter: false, realGripImplemented: false, realAssetsImplemented: false, effectsImplemented: false, binaryResultReserved: true, watDefault: false },
+    scope: ['compiled handlers driven through host runtime', 'schema JSON sidecar through host runtime', 'library sidecar fixture through host runtime', 'RESULT_STREAM through host runtime and Node adapter', 'no pulsewasm_handlers JS imports'],
+    reserved: ['real pulse.grip', 'real pulse.assets', 'effect execution', 'ctx.fetch', 'ctx.resolve', 'ctx.sleep', 'RESULT_BINARY', 'platform adapters'],
+    smoke: smoke.summary,
+    hostRuntime: hostRuntime.summary,
+    nodeAdapter: nodeAdapter.summary,
+    diagnostics: diagnostics.map((diag) => diag.code),
+    summary: { compiled: smoke.summary.compiled, executed: smoke.summary.executed, checks: smoke.summary.checks, failedChecks: smoke.summary.failedChecks, jsHandlerImports: smoke.summary.jsHandlerImports, hostRuntimeDriven: true, nodeAdapterDriven: smoke.summary.nodeAdapterStreamForwarding, schemaParseThroughHostRuntime: true, librarySidecarThroughHostRuntime: true, streamThroughNodeAdapter: smoke.summary.nodeAdapterStreamForwarding, diagnostics: diagnostics.length }
+  }, cwd);
+  files[5] = makeFile('generated/host/compiled-wasm-runtime.md', buildMarkdown(artifact));
+  return { artifact, hostRuntime, nodeAdapter, smoke, files, outputFiles: compile.outputFiles || [], diagnostics };
+}
+
+module.exports = { COMPILED_WASM_RUNTIME_VERSION, COMPILED_WASM_HOST_RUNTIME_VERSION, COMPILED_WASM_NODE_ADAPTER_VERSION, COMPILED_WASM_RUNTIME_SMOKE_VERSION, buildCompiledWasmRuntime };