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

package/src/compiler/wasm-host-bridge.js

@@ -0,0 +1,984 @@
+'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 { spawnSync } = require('node:child_process');
+const { PACKAGE_VERSION, normalizeArtifact, normalizeDiagnostic } = require('@pulse-compute/wasm-contracts/diagnostics');
+
+function diagnosticFromParts(parts) {
+  return normalizeDiagnostic({ severity: 'error', loc: { file: '<generated>' }, ...parts });
+}
+
+const WASM_BRIDGE_VERSION = 'pulsewasm.wasm-host-bridge.v3';
+const WASM_BRIDGE_PHASE = '12D';
+const BRIDGE_RUNNER_FILE = 'generated/host-bridge/host-bridge-runner.as.ts';
+const BRIDGE_WASM_REL = 'generated/wasm-bridge/pulsewasm-host-bridge.wasm';
+const BRIDGE_WAT_REL = 'generated/wasm-bridge/pulsewasm-host-bridge.wat';
+
+function sha256Buffer(buffer) { return crypto.createHash('sha256').update(buffer).digest('hex'); }
+function sha256Text(text) { return crypto.createHash('sha256').update(text, 'utf8').digest('hex'); }
+function stripAnsi(value) { return String(value || '').replace(/\u001b\[[0-9;]*m/g, ''); }
+
+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 result.stderr for details.' });
+  }
+  return warnings;
+}
+
+function assemblyScriptVersion(cwd) {
+  try {
+    const packageJson = require.resolve('assemblyscript/package.json', { paths: [cwd] });
+    return JSON.parse(fs.readFileSync(packageJson, 'utf8')).version;
+  } catch (_) {
+    return undefined;
+  }
+}
+
+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 writeStagedFiles(stagingDir, shape, core, bridgeRunnerText) {
+  const allFiles = [];
+  if (shape && Array.isArray(shape.files)) allFiles.push(...shape.files);
+  if (core && Array.isArray(core.files)) allFiles.push(...core.files);
+  const byFile = new Map();
+  for (const file of allFiles) byFile.set(file.file, file.text);
+  byFile.set(BRIDGE_RUNNER_FILE, bridgeRunnerText);
+  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 buildBridgeRunnerSource() {
+  return `/*
+ * Generated by PulseWasm Phase 12D.
+ * Do not edit by hand.
+ *
+ * This file adapts the generated AssemblyScript routing core to the locked
+ * Wasm Host ABI v4 so Node can drive the compiled Wasm through ptr+byteLen
+ * strings, ordered repeated headers, and exported continuation/result helpers.
+ */
+import {
+  METHOD_GET,
+  METHOD_POST,
+  CHANNEL_HANDLER
+} from '../as/types.as'
+
+import {
+  EXECUTION_ENTRY_COUNT,
+  ROUTE_COUNT
+} from '../as/route-table.as'
+
+import {
+  HANDLER_BINDING_COUNT
+} from '../as/handler-slots.as'
+
+import {
+  PulseWasmDispatchState,
+  PulseWasmErrorRef,
+  createDispatchState,
+  createPulseWasmError,
+  stepDispatchState,
+  continueNormal,
+  continueError,
+  pulse_set_result,
+  defaultStatusForStepResult,
+  STEP_INVOKE,
+  STEP_NOT_FOUND,
+  STEP_UNHANDLED_ERROR,
+  STEP_CONTRACT_VIOLATION,
+  NEXT_NORMAL,
+  NEXT_ERROR,
+  ENTRY_ROUTE,
+  invokeCurrentHandler,
+  currentParamCount,
+  currentParamNameAt,
+  currentParamValueAt,
+  scopeChannelKind,
+  scopeChannelSlot,
+  scopeConnectLength,
+  scopeConnectSlotAt,
+  scopeDisconnectLength,
+  scopeDisconnectSlotAt,
+  invokeChannelHandler,
+  invokeLifecycleHandler
+} from '../as/runtime-core.as'
+
+@external('pulsewasm_broadcaster', 'broadcast')
+declare function __pulsewasm_broadcast(channelsRef: usize, ctxRef: usize): i32
+
+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
+
+export const HOST_BRIDGE_OK: i32 = 0
+export const HOST_BRIDGE_NOT_FOUND: i32 = 404
+export const HOST_BRIDGE_INTERNAL_ERROR: i32 = 500
+export const HOST_BRIDGE_BROADCASTER_ERROR: i32 = 590
+
+let __currentState: PulseWasmDispatchState | null = null
+let __resultStatus: i32 = 0
+let __resultKind: i32 = RESULT_NONE
+let __resultBodyPtr: usize = 0
+let __resultBodyLen: i32 = 0
+let __resultHeadersRef: usize = 0
+let __resultErrorRef: usize = 0
+let __resultStreamRef: usize = 0
+let __resultResponseRef: usize = 0
+let __lastStringBuffer: ArrayBuffer | null = null
+let __lastHeaderBuffer: ArrayBuffer | null = null
+let __lastChannelsRef: usize = 0
+let __lastBroadcastResult: i32 = 0
+let __lastInvokedHandlers: i32 = 0
+
+
+let __requestHeaderNames = new Array<string>()
+let __requestHeaderLowerNames = new Array<string>()
+let __requestHeaderValues = new Array<string>()
+let __responseHeaderNames = new Array<string>()
+let __responseHeaderLowerNames = new Array<string>()
+let __responseHeaderValues = new Array<string>()
+let __responseHeaderModes = new Array<i32>()
+let __responseHeaderDeletedNames = new Array<string>()
+let __responseHeaderDeletedLowerNames = new Array<string>()
+
+function decodeUtf8(ptr: usize, len: i32): string {
+  if (ptr == 0 || len <= 0) return ''
+  return String.UTF8.decodeUnsafe(ptr, len, true)
+}
+
+function stringRef(value: string): usize { return changetype<usize>(value) }
+
+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 clearRequestHeaders(): void {
+  __requestHeaderNames.length = 0
+  __requestHeaderLowerNames.length = 0
+  __requestHeaderValues.length = 0
+}
+
+function clearResponseHeaders(): void {
+  __responseHeaderNames.length = 0
+  __responseHeaderLowerNames.length = 0
+  __responseHeaderValues.length = 0
+  __responseHeaderModes.length = 0
+  __responseHeaderDeletedNames.length = 0
+  __responseHeaderDeletedLowerNames.length = 0
+  __resultHeadersRef = 0
+}
+
+function appendHeader(names: Array<string>, lowerNames: Array<string>, values: Array<string>, name: string, value: string): void {
+  names.push(name)
+  lowerNames.push(lowerAscii(name))
+  values.push(value)
+}
+
+function appendResponseHeader(name: string, value: string, mode: i32): void {
+  __responseHeaderNames.push(name)
+  __responseHeaderLowerNames.push(lowerAscii(name))
+  __responseHeaderValues.push(value)
+  __responseHeaderModes.push(mode)
+  __resultHeadersRef = 1
+}
+
+function headerCount(lowerNames: Array<string>, lowerName: string): i32 {
+  let count: i32 = 0
+  for (let i: i32 = 0; i < lowerNames.length; i += 1) {
+    if (lowerNames[i] == lowerName) count += 1
+  }
+  return count
+}
+
+function matchingHeaderIndex(lowerNames: Array<string>, lowerName: string, ordinal: i32): i32 {
+  let seen: i32 = 0
+  for (let i: i32 = 0; i < lowerNames.length; i += 1) {
+    if (lowerNames[i] == lowerName) {
+      if (seen == ordinal) return i
+      seen += 1
+    }
+  }
+  return -1
+}
+
+function deleteResponseHeadersByLower(lowerName: string): void {
+  const names = new Array<string>()
+  const lowerNames = new Array<string>()
+  const values = new Array<string>()
+  const modes = new Array<i32>()
+  for (let i: i32 = 0; i < __responseHeaderNames.length; i += 1) {
+    if (__responseHeaderLowerNames[i] != lowerName) {
+      names.push(__responseHeaderNames[i])
+      lowerNames.push(__responseHeaderLowerNames[i])
+      values.push(__responseHeaderValues[i])
+      modes.push(__responseHeaderModes[i])
+    }
+  }
+  __responseHeaderNames = names
+  __responseHeaderLowerNames = lowerNames
+  __responseHeaderValues = values
+  __responseHeaderModes = modes
+  __resultHeadersRef = __responseHeaderNames.length > 0 ? 1 : 0
+}
+
+function headerStringPtr(value: string): i32 {
+  const encoded = String.UTF8.encode(value, true)
+  __lastHeaderBuffer = encoded
+  return changetype<i32>(encoded)
+}
+
+function resetResult(): void {
+  __resultStatus = 0
+  __resultKind = RESULT_NONE
+  __resultBodyPtr = 0
+  __resultBodyLen = 0
+  __resultErrorRef = 0
+  __resultStreamRef = 0
+  __resultResponseRef = 0
+  __lastStringBuffer = null
+  __lastHeaderBuffer = null
+  clearResponseHeaders()
+  __lastChannelsRef = 0
+  __lastBroadcastResult = 0
+  __lastInvokedHandlers = 0
+}
+
+function setEmptyResult(statusCode: i32): void {
+  __resultStatus = statusCode
+  __resultKind = RESULT_EMPTY
+  __resultBodyPtr = 0
+  __resultBodyLen = 0
+}
+
+function setErrorResult(statusCode: i32, errorRef: usize): void {
+  __resultStatus = statusCode
+  __resultKind = RESULT_TEXT
+  __resultErrorRef = errorRef
+}
+
+function currentStateFromCtx(ctxRef: usize): PulseWasmDispatchState {
+  return changetype<PulseWasmDispatchState>(ctxRef)
+}
+
+function maybeBroadcastForState(state: PulseWasmDispatchState): void {
+  const scopeId = state.currentScopeId
+  if (scopeId < 0) return
+  if (scopeChannelKind(scopeId) != CHANNEL_HANDLER) return
+  const slot = scopeChannelSlot(scopeId)
+  if (slot < 0) return
+  const channelsRef = invokeChannelHandler(slot, changetype<usize>(state))
+  if (channelsRef == 0) return
+  __lastChannelsRef = channelsRef
+  const result = __pulsewasm_broadcast(channelsRef, changetype<usize>(state))
+  __lastBroadcastResult = result
+  if (result != 0) setErrorResult(HOST_BRIDGE_INTERNAL_ERROR, result)
+}
+
+function executeState(state: PulseWasmDispatchState): i32 {
+  __currentState = state
+  let guard: i32 = 0
+  while (guard < EXECUTION_ENTRY_COUNT + 16) {
+    guard += 1
+    const step = stepDispatchState(state)
+    if (step == STEP_INVOKE) {
+      __lastInvokedHandlers += 1
+      const invoked = invokeCurrentHandler(state)
+      if (!invoked) {
+        setErrorResult(HOST_BRIDGE_INTERNAL_ERROR, changetype<usize>(createPulseWasmError('PULSEWASM_HANDLER_NOT_BOUND', 'Handler slot could not be invoked.', HOST_BRIDGE_INTERNAL_ERROR)))
+        return __resultStatus
+      }
+      if (__resultStatus != 0 || __resultKind != RESULT_NONE) {
+        maybeBroadcastForState(state)
+        return __resultStatus
+      }
+      if (state.nextOutcome == NEXT_NORMAL || state.nextOutcome == NEXT_ERROR) continue
+      setErrorResult(HOST_BRIDGE_INTERNAL_ERROR, changetype<usize>(createPulseWasmError('PULSEWASM_NO_RESULT', 'Handler halted without result or continuation.', HOST_BRIDGE_INTERNAL_ERROR)))
+      return __resultStatus
+    }
+    if (step == STEP_NOT_FOUND) { setEmptyResult(404); return __resultStatus }
+    if (step == STEP_UNHANDLED_ERROR) { setErrorResult(500, state.activeError); return __resultStatus }
+    if (step == STEP_CONTRACT_VIOLATION) {
+      setErrorResult(500, changetype<usize>(createPulseWasmError('PULSEWASM_NO_RESULT', 'Handler halted without result or continuation.', 500)))
+      return __resultStatus
+    }
+    const fallback = defaultStatusForStepResult(step)
+    if (fallback != 0) { setEmptyResult(fallback); return __resultStatus }
+    setErrorResult(500, changetype<usize>(createPulseWasmError('PULSEWASM_INVALID_STEP', 'Invalid routing step result.', 500)))
+    return __resultStatus
+  }
+  setErrorResult(500, changetype<usize>(createPulseWasmError('PULSEWASM_DISPATCH_GUARD_EXHAUSTED', 'Dispatch guard exhausted.', 500)))
+  return __resultStatus
+}
+
+function findScopeForPath(methodCode: i32, requestPath: string): PulseWasmDispatchState {
+  const state = createDispatchState(methodCode, requestPath)
+  let guard: i32 = 0
+  while (guard < EXECUTION_ENTRY_COUNT + 16) {
+    guard += 1
+    const step = stepDispatchState(state)
+    if (step != STEP_INVOKE) return state
+    if (state.currentKind == ENTRY_ROUTE) return state
+    continueNormal(state)
+  }
+  return state
+}
+
+function executeLifecycleForScope(state: PulseWasmDispatchState, eventKind: i32): i32 {
+  __currentState = state
+  let invoked: i32 = 0
+  const scopeId = state.currentScopeId
+  const length = eventKind == 1 ? scopeConnectLength(scopeId) : scopeDisconnectLength(scopeId)
+  for (let i: i32 = 0; i < length; i += 1) {
+    const slot = eventKind == 1 ? scopeConnectSlotAt(scopeId, i) : scopeDisconnectSlotAt(scopeId, i)
+    if (slot >= 0 && invokeLifecycleHandler(slot, changetype<usize>(state), changetype<usize>(state))) invoked += 1
+  }
+  return invoked
+}
+
+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 {
+  __currentState = null
+  clearRequestHeaders()
+  resetResult()
+}
+
+export function pulse_execute_request(methodCode: i32, pathPtr: i32, pathLen: i32): i32 {
+  resetResult()
+  const state = createDispatchState(methodCode, decodeUtf8(pathPtr, pathLen))
+  return executeState(state)
+}
+
+export function pulse_execute_connect(methodCode: i32, pathPtr: i32, pathLen: i32): i32 {
+  resetResult()
+  const state = findScopeForPath(methodCode, decodeUtf8(pathPtr, pathLen))
+  return executeLifecycleForScope(state, 1)
+}
+
+export function pulse_execute_disconnect(methodCode: i32, pathPtr: i32, pathLen: i32): i32 {
+  resetResult()
+  const state = findScopeForPath(methodCode, decodeUtf8(pathPtr, pathLen))
+  return executeLifecycleForScope(state, 2)
+}
+
+export function pulse_result_status(): i32 { return __resultStatus }
+export function pulse_result_kind(): i32 { return __resultKind }
+export function pulse_result_body_ref(): i32 { return __resultBodyPtr == 0 ? 0 : 1 }
+export function pulse_result_body_ptr(): i32 { return __resultBodyPtr as i32 }
+export function pulse_result_body_len(): i32 { return __resultBodyLen }
+export function pulse_result_headers_ref(): i32 { return __resultHeadersRef as i32 }
+export function pulse_result_error_ref(): i32 { return __resultErrorRef as i32 }
+export function pulse_result_stream_ref(): i32 { return __resultStreamRef as i32 }
+export function pulse_result_response_ref(): i32 { return __resultResponseRef as i32 }
+
+export function pulse_request_header_first(ctxRef: i32, namePtr: i32, nameLen: i32): i32 {
+  const lowerName = lowerAscii(decodeUtf8(namePtr as usize, nameLen))
+  const index = matchingHeaderIndex(__requestHeaderLowerNames, lowerName, 0)
+  return index < 0 ? 0 : stringRef(__requestHeaderValues[index]) as i32
+}
+
+export function pulse_request_header_count(ctxRef: i32, namePtr: i32, nameLen: i32): i32 {
+  return headerCount(__requestHeaderLowerNames, lowerAscii(decodeUtf8(namePtr as usize, nameLen)))
+}
+
+export function pulse_request_header_at(ctxRef: i32, namePtr: i32, nameLen: i32, index: i32): i32 {
+  const lowerName = lowerAscii(decodeUtf8(namePtr as usize, nameLen))
+  const actual = matchingHeaderIndex(__requestHeaderLowerNames, lowerName, index)
+  return actual < 0 ? 0 : stringRef(__requestHeaderValues[actual]) as i32
+}
+
+export function pulse_response_header_set(ctxRef: i32, namePtr: i32, nameLen: i32, valuePtr: i32, valueLen: i32): void {
+  const name = decodeUtf8(namePtr as usize, nameLen)
+  const value = decodeUtf8(valuePtr as usize, valueLen)
+  deleteResponseHeadersByLower(lowerAscii(name))
+  appendResponseHeader(name, value, 1)
+}
+
+export function pulse_response_header_append(ctxRef: i32, namePtr: i32, nameLen: i32, valuePtr: i32, valueLen: i32): void {
+  appendResponseHeader(decodeUtf8(namePtr as usize, nameLen), decodeUtf8(valuePtr as usize, valueLen), 2)
+}
+
+export function pulse_response_header_delete(ctxRef: i32, namePtr: i32, nameLen: i32): void {
+  const name = decodeUtf8(namePtr as usize, nameLen)
+  const lower = lowerAscii(name)
+  __responseHeaderDeletedNames.push(name)
+  __responseHeaderDeletedLowerNames.push(lower)
+  deleteResponseHeadersByLower(lower)
+}
+
+export function pulse_result_header_count(): i32 { return __responseHeaderNames.length }
+export function pulse_result_header_name_ptr(index: i32): i32 { return index < 0 || index >= __responseHeaderNames.length ? 0 : headerStringPtr(__responseHeaderNames[index]) }
+export function pulse_result_header_name_len(index: i32): i32 { return index < 0 || index >= __responseHeaderNames.length ? 0 : String.UTF8.byteLength(__responseHeaderNames[index]) }
+export function pulse_result_header_value_ptr(index: i32): i32 { return index < 0 || index >= __responseHeaderValues.length ? 0 : headerStringPtr(__responseHeaderValues[index]) }
+export function pulse_result_header_value_len(index: i32): i32 { return index < 0 || index >= __responseHeaderValues.length ? 0 : String.UTF8.byteLength(__responseHeaderValues[index]) }
+export function pulse_result_header_mode(index: i32): i32 { return index < 0 || index >= __responseHeaderModes.length ? 2 : __responseHeaderModes[index] }
+export function pulse_result_header_delete_count(): i32 { return __responseHeaderDeletedNames.length }
+export function pulse_result_header_delete_name_ptr(index: i32): i32 { return index < 0 || index >= __responseHeaderDeletedNames.length ? 0 : headerStringPtr(__responseHeaderDeletedNames[index]) }
+export function pulse_result_header_delete_name_len(index: i32): i32 { return index < 0 || index >= __responseHeaderDeletedNames.length ? 0 : String.UTF8.byteLength(__responseHeaderDeletedNames[index]) }
+
+export function pulse_string_ptr(stringRef: i32): i32 {
+  if (stringRef == 0) return 0
+  const value = changetype<string>(stringRef)
+  const encoded = String.UTF8.encode(value, true)
+  __lastStringBuffer = encoded
+  return changetype<i32>(encoded)
+}
+export function pulse_string_len(stringRef: i32): i32 { return stringRef == 0 ? 0 : String.UTF8.byteLength(changetype<string>(stringRef)) }
+export function pulse_string_is_null(stringRef: i32): i32 { return stringRef == 0 ? 1 : 0 }
+
+export function pulse_ctx_param(ctxRef: i32, namePtr: i32, nameLen: i32): i32 {
+  const state = currentStateFromCtx(ctxRef as usize)
+  const name = decodeUtf8(namePtr as usize, nameLen)
+  const count = currentParamCount(state)
+  for (let i: i32 = 0; i < count; i += 1) {
+    if (currentParamNameAt(state, i) == name) return stringRef(currentParamValueAt(state, i)) as i32
+  }
+  return 0
+}
+
+export function pulse_ctx_state_get(ctxRef: i32, keyPtr: i32, keyLen: i32): i32 {
+  const state = currentStateFromCtx(ctxRef as usize)
+  const key = decodeUtf8(keyPtr as usize, keyLen)
+  for (let i: i32 = 0; i < state.stateKeys.length; i += 1) if (state.stateKeys[i] == key) return stringRef(state.stateValues[i]) as i32
+  return 0
+}
+
+export function pulse_ctx_state_set(ctxRef: i32, keyPtr: i32, keyLen: i32, valuePtr: i32, valueLen: i32): void {
+  const state = currentStateFromCtx(ctxRef as usize)
+  const key = decodeUtf8(keyPtr as usize, keyLen)
+  const value = decodeUtf8(valuePtr as usize, valueLen)
+  for (let i: i32 = 0; i < state.stateKeys.length; i += 1) {
+    if (state.stateKeys[i] == key) { state.stateValues[i] = value; return }
+  }
+  state.stateKeys.push(key)
+  state.stateValues.push(value)
+}
+
+export function pulse_result_text(ctxRef: i32, statusCode: i32, bodyPtr: i32, bodyLen: i32): void {
+  __resultStatus = statusCode
+  __resultKind = RESULT_TEXT
+  __resultBodyPtr = bodyPtr as usize
+  __resultBodyLen = bodyLen
+  pulse_set_result(currentStateFromCtx(ctxRef as usize), 1)
+}
+
+export function pulse_result_empty(ctxRef: i32, statusCode: i32): void {
+  __resultStatus = statusCode
+  __resultKind = RESULT_EMPTY
+  __resultBodyPtr = 0
+  __resultBodyLen = 0
+  pulse_set_result(currentStateFromCtx(ctxRef as usize), 1)
+}
+
+export function pulse_result_stream(ctxRef: i32, statusCode: i32, streamRef: i32): void {
+  __resultStatus = statusCode
+  __resultKind = RESULT_STREAM
+  __resultStreamRef = streamRef as usize
+  __resultResponseRef = 0
+  __resultBodyPtr = 0
+  __resultBodyLen = 0
+  pulse_set_result(currentStateFromCtx(ctxRef as usize), 1)
+}
+
+export function pulse_result_from_response(ctxRef: i32, responseRef: i32): void {
+  __resultStatus = 0
+  __resultKind = RESULT_STREAM
+  __resultResponseRef = responseRef as usize
+  __resultStreamRef = 0
+  __resultBodyPtr = 0
+  __resultBodyLen = 0
+  pulse_set_result(currentStateFromCtx(ctxRef as usize), 1)
+}
+
+export function pulse_next(ctxRef: i32): void { continueNormal(currentStateFromCtx(ctxRef as usize)) }
+export function pulse_next_error(ctxRef: i32, errorRef: i32): void { continueError(currentStateFromCtx(ctxRef as usize), errorRef as usize) }
+
+export function pulse_error(codePtr: i32, codeLen: i32, messagePtr: i32, messageLen: i32, statusCode: i32): i32 {
+  const error = createPulseWasmError(decodeUtf8(codePtr as usize, codeLen), decodeUtf8(messagePtr as usize, messageLen), statusCode)
+  return changetype<i32>(error)
+}
+
+export function pulse_error_with_cause(codePtr: i32, codeLen: i32, messagePtr: i32, messageLen: i32, statusCode: i32, causeRef: i32): i32 {
+  const error = createPulseWasmError(decodeUtf8(codePtr as usize, codeLen), decodeUtf8(messagePtr as usize, messageLen), statusCode, causeRef as usize)
+  return changetype<i32>(error)
+}
+
+export function pulse_error_code_ref(errorRef: i32): i32 { return errorRef == 0 ? 0 : stringRef(changetype<PulseWasmErrorRef>(errorRef).code) as i32 }
+export function pulse_error_message_ref(errorRef: i32): i32 { return errorRef == 0 ? 0 : stringRef(changetype<PulseWasmErrorRef>(errorRef).message) as i32 }
+export function pulse_error_status_code(errorRef: i32): i32 { return errorRef == 0 ? 0 : changetype<PulseWasmErrorRef>(errorRef).statusCode }
+export function pulse_error_cause_ref(errorRef: i32): i32 { return errorRef == 0 ? 0 : changetype<PulseWasmErrorRef>(errorRef).cause as i32 }
+
+export function pulse_channel_count(channelsRef: i32): i32 { return channelsRef == 0 ? 0 : 1 }
+export function pulse_channel_ref_at(channelsRef: i32, index: i32): i32 { return index == 0 ? channelsRef : 0 }
+
+export function pulse_bridge_request_headers_clear(): void { clearRequestHeaders() }
+export function pulse_bridge_request_header_append(namePtr: i32, nameLen: i32, valuePtr: i32, valueLen: i32): void {
+  appendHeader(__requestHeaderNames, __requestHeaderLowerNames, __requestHeaderValues, decodeUtf8(namePtr as usize, nameLen), decodeUtf8(valuePtr as usize, valueLen))
+}
+export function pulse_bridge_request_header_total(): i32 { return __requestHeaderNames.length }
+
+export function pulse_bridge_route_count(): i32 { return ROUTE_COUNT }
+export function pulse_bridge_execution_entry_count(): i32 { return EXECUTION_ENTRY_COUNT }
+export function pulse_bridge_handler_binding_count(): i32 { return HANDLER_BINDING_COUNT }
+export function pulse_bridge_last_channels_ref(): i32 { return __lastChannelsRef as i32 }
+export function pulse_bridge_last_broadcast_result(): i32 { return __lastBroadcastResult }
+export function pulse_bridge_last_invoked_handlers(): i32 { return __lastInvokedHandlers }
+export function pulse_bridge_method_get(): i32 { return METHOD_GET }
+export function pulse_bridge_method_post(): i32 { return METHOD_POST }
+`;
+}
+
+function ascExecutable(cwd) {
+  try {
+    const ascPath = require.resolve('assemblyscript/bin/asc.js', { paths: [cwd] });
+    return { command: process.execPath, argsPrefix: [ascPath], display: `node ${path.relative(cwd, ascPath).replace(/\\/g, '/')}` };
+  } catch (_) {
+    return undefined;
+  }
+}
+
+function compileBridge(stagingDir, cwd, options = {}) {
+  const asc = ascExecutable(cwd);
+  if (!asc) {
+    return {
+      asc,
+      result: { status: 1, stdout: '', stderr: 'assemblyscript package is not installed.' },
+      diagnostics: [diagnosticFromParts({
+        phase: 'wasm-host-bridge',
+        code: 'PULSEWASM_ASSEMBLYSCRIPT_NOT_INSTALLED',
+        message: 'AssemblyScript is required for Phase 10D Wasm host bridge compilation.',
+        hint: 'Run npm install before requesting --emit-wasm-host-bridge or --emit-request-result-headers.'
+      })]
+    };
+  }
+
+  const outDir = options.outDir ? path.resolve(cwd, options.outDir) : getDefaultArtifactsDir(cwd);
+  const wasmFile = path.join(outDir, BRIDGE_WASM_REL);
+  const watFile = path.join(outDir, BRIDGE_WAT_REL);
+  fs.mkdirSync(path.dirname(wasmFile), { recursive: true });
+  fs.mkdirSync(path.dirname(watFile), { recursive: true });
+  const input = path.join(stagingDir, BRIDGE_RUNNER_FILE);
+  const args = [...asc.argsPrefix, input, '--outFile', wasmFile, '--textFile', watFile, '--runtime', 'stub', '--noAssert'];
+  const started = Date.now();
+  const result = spawnSync(asc.command, args, { cwd, encoding: 'utf8', maxBuffer: 1024 * 1024 * 20 });
+  const durationMs = Date.now() - started;
+  const warnings = parseAscWarnings(result.stderr || '');
+  const diagnostics = [];
+  if (result.error || result.status !== 0) {
+    diagnostics.push(diagnosticFromParts({
+      phase: 'wasm-host-bridge',
+      code: 'PULSEWASM_WASM_HOST_BRIDGE_COMPILE_FAILED',
+      message: 'Phase 10D Wasm host bridge compile failed.',
+      hint: 'Inspect wasm-host-bridge.json result.stderr for AssemblyScript diagnostics.',
+      details: { exitCode: result.status, stderr: result.stderr || '', stdout: result.stdout || '', error: result.error ? result.error.message : undefined }
+    }));
+  }
+  if (warnings.length > 0) {
+    diagnostics.push(diagnosticFromParts({
+      phase: 'wasm-host-bridge',
+      code: 'PULSEWASM_WASM_HOST_BRIDGE_WARNINGS',
+      message: 'Phase 10D Wasm host bridge emitted AssemblyScript warnings.',
+      hint: 'Warnings are treated as failures at this ABI boundary.',
+      details: { warnings }
+    }));
+  }
+  return { asc, args, wasmFile, watFile, durationMs, warnings, result, diagnostics };
+}
+
+function instantiateWithoutBroadcaster(wasmFile) {
+  try {
+    const wasm = fs.readFileSync(wasmFile);
+    const module = new WebAssembly.Module(wasm);
+    const importObject = { env: { abort() { throw new Error('abort'); } }, pulsewasm_handlers: {} };
+    for (const imp of WebAssembly.Module.imports(module)) if (imp.module === 'pulsewasm_handlers') importObject.pulsewasm_handlers[imp.name] = () => 0;
+    new WebAssembly.Instance(module, importObject);
+    return { missingBroadcasterRejected: false, error: undefined };
+  } catch (error) {
+    return { missingBroadcasterRejected: true, error: error && error.message ? error.message : String(error) };
+  }
+}
+
+function instantiateAndRunBridge(wasmFile) {
+  const wasm = fs.readFileSync(wasmFile);
+  const module = new WebAssembly.Module(wasm);
+  const imports = WebAssembly.Module.imports(module);
+  const exports = WebAssembly.Module.exports(module);
+  let instance;
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  const handlerCalls = {};
+  const observedParams = {};
+  const observedState = {};
+  const observedHeaders = {};
+  const broadcasterCalls = [];
+
+  function memory() { return instance.exports.memory; }
+  function allocBytes(text) {
+    const bytes = encoder.encode(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 };
+  }
+  function readBytes(ptr, len) { return (!ptr || !len) ? '' : 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 setResultText(ctx, status, body) {
+    const encoded = allocBytes(body);
+    instance.exports.pulse_result_text(ctx, status, encoded.ptr, encoded.len);
+  }
+  function getParam(ctx, name) {
+    const encoded = allocBytes(name);
+    return readStringRef(instance.exports.pulse_ctx_param(ctx, encoded.ptr, encoded.len));
+  }
+  function stateSet(ctx, key, value) {
+    const k = allocBytes(key); const v = allocBytes(value);
+    instance.exports.pulse_ctx_state_set(ctx, k.ptr, k.len, v.ptr, v.len);
+  }
+  function stateGet(ctx, key) {
+    const k = allocBytes(key);
+    return readStringRef(instance.exports.pulse_ctx_state_get(ctx, k.ptr, k.len));
+  }
+  function requestHeaderFirst(ctx, name) {
+    const n = allocBytes(name);
+    return readStringRef(instance.exports.pulse_request_header_first(ctx, n.ptr, n.len));
+  }
+  function requestHeaderCount(ctx, name) {
+    const n = allocBytes(name);
+    return instance.exports.pulse_request_header_count(ctx, n.ptr, n.len);
+  }
+  function requestHeaderAt(ctx, name, index) {
+    const n = allocBytes(name);
+    return readStringRef(instance.exports.pulse_request_header_at(ctx, n.ptr, n.len, index));
+  }
+  function responseHeaderSet(ctx, name, value) {
+    const n = allocBytes(name); const v = allocBytes(value);
+    instance.exports.pulse_response_header_set(ctx, n.ptr, n.len, v.ptr, v.len);
+  }
+  function responseHeaderAppend(ctx, name, value) {
+    const n = allocBytes(name); const v = allocBytes(value);
+    instance.exports.pulse_response_header_append(ctx, n.ptr, n.len, v.ptr, v.len);
+  }
+  function responseHeaderDelete(ctx, name) {
+    const n = allocBytes(name);
+    instance.exports.pulse_response_header_delete(ctx, n.ptr, n.len);
+  }
+  function requestHeadersClear() { instance.exports.pulse_bridge_request_headers_clear(); }
+  function requestHeaderAppend(name, value) {
+    const n = allocBytes(name); const v = allocBytes(value);
+    instance.exports.pulse_bridge_request_header_append(n.ptr, n.len, v.ptr, v.len);
+  }
+  function readResultHeaders() {
+    const headers = [];
+    const count = instance.exports.pulse_result_header_count();
+    for (let i = 0; i < count; i += 1) {
+      headers.push({
+        name: readBytes(instance.exports.pulse_result_header_name_ptr(i), instance.exports.pulse_result_header_name_len(i)),
+        value: readBytes(instance.exports.pulse_result_header_value_ptr(i), instance.exports.pulse_result_header_value_len(i))
+      });
+    }
+    return headers;
+  }
+  function headerValues(headers, name) {
+    const lower = String(name).toLowerCase();
+    return headers.filter((header) => String(header.name).toLowerCase() === lower).map((header) => header.value);
+  }
+  function makeError(code, message, status) {
+    const c = allocBytes(code); const m = allocBytes(message);
+    return instance.exports.pulse_error(c.ptr, c.len, m.ptr, m.len, status);
+  }
+
+  const importObject = {
+    env: { abort(message, file, line, column) { throw new Error(`AssemblyScript abort(${message}, ${file}, ${line}, ${column})`); } },
+    pulsewasm_handlers: {},
+    pulsewasm_broadcaster: { broadcast(channelsRef, ctxRef) { broadcasterCalls.push({ channelsRef, ctxRef }); return 0; } }
+  };
+
+  for (const imp of imports) {
+    if (imp.module === 'pulsewasm_handlers') {
+      importObject.pulsewasm_handlers[imp.name] = (a, b, c) => {
+        handlerCalls[imp.name] = (handlerCalls[imp.name] || 0) + 1;
+        if (imp.name === 'auth') {
+          const first = requestHeaderFirst(a, 'X-Pulse-Test');
+          const multiCount = requestHeaderCount(a, 'X-Pulse-Multi');
+          const multiSecond = requestHeaderAt(a, 'X-Pulse-Multi', 1);
+          if (first !== undefined && observedHeaders.requestFirst === undefined) observedHeaders.requestFirst = first;
+          if (multiCount > (observedHeaders.requestMultiCount || 0)) observedHeaders.requestMultiCount = multiCount;
+          if (multiSecond !== undefined && observedHeaders.requestMultiSecond === undefined) observedHeaders.requestMultiSecond = multiSecond;
+          stateSet(a, 'auth', '1');
+          instance.exports.pulse_next(a);
+          return 0;
+        }
+        if (imp.name === 'gateway') {
+          observedState.gatewaySawAuth = stateGet(a, 'auth');
+          instance.exports.pulse_next(a);
+          return 0;
+        }
+        if (imp.name === 'computeHandler') {
+          const id = getParam(a, 'id');
+          observedParams.computeId = id;
+          responseHeaderAppend(a, 'Temp-Header', 'remove-me');
+          responseHeaderDelete(a, 'Temp-Header');
+          responseHeaderSet(a, 'Content-Type', 'text/plain');
+          setResultText(a, 201, `compute:${id}`);
+          return 0;
+        }
+        if (imp.name === 'realtimeHandler') {
+          const id = getParam(a, 'id');
+          observedParams.realtimeId = id;
+          responseHeaderSet(a, 'Content-Type', 'text/plain');
+          responseHeaderSet(a, 'Grip-Hold', 'stream');
+          responseHeaderAppend(a, 'Grip-Channel', 'realtime');
+          responseHeaderAppend(a, 'Grip-Channel', `realtime:${id}`);
+          setResultText(a, 200, `realtime:${id}`);
+          return 0;
+        }
+        if (imp.name === 'bundleChannel') return 0xC0DE;
+        if (imp.name === 'onConnect' || imp.name === 'onDisconnect') return 0;
+        if (imp.name.toLowerCase().includes('error')) { instance.exports.pulse_next(a || b || c || 0); return 0; }
+        return 0;
+      };
+    }
+  }
+
+  instance = new WebAssembly.Instance(module, importObject);
+
+  function executeRequest(methodCode, requestPath, headers = []) {
+    requestHeadersClear();
+    for (const header of headers) requestHeaderAppend(header.name, header.value);
+    const pathBytes = allocBytes(requestPath);
+    const status = instance.exports.pulse_execute_request(methodCode, pathBytes.ptr, pathBytes.len);
+    const resultHeaders = readResultHeaders();
+    return {
+      status,
+      resultStatus: instance.exports.pulse_result_status(),
+      resultKind: instance.exports.pulse_result_kind(),
+      body: readBytes(instance.exports.pulse_result_body_ptr(), instance.exports.pulse_result_body_len()),
+      headers: resultHeaders,
+      headerCount: resultHeaders.length,
+      gripChannels: headerValues(resultHeaders, 'Grip-Channel'),
+      errorRef: instance.exports.pulse_result_error_ref(),
+      streamRef: instance.exports.pulse_result_stream_ref ? instance.exports.pulse_result_stream_ref() : 0,
+      responseRef: instance.exports.pulse_result_response_ref ? instance.exports.pulse_result_response_ref() : 0,
+      lastChannelsRef: instance.exports.pulse_bridge_last_channels_ref(),
+      lastBroadcastResult: instance.exports.pulse_bridge_last_broadcast_result(),
+      invokedHandlers: instance.exports.pulse_bridge_last_invoked_handlers()
+    };
+  }
+
+  function executeLifecycle(kind, methodCode, requestPath) {
+    const pathBytes = allocBytes(requestPath);
+    const fn = kind === 'connect' ? instance.exports.pulse_execute_connect : instance.exports.pulse_execute_disconnect;
+    return fn(methodCode, pathBytes.ptr, pathBytes.len);
+  }
+
+  const methodGet = instance.exports.pulse_bridge_method_get();
+  const methodPost = instance.exports.pulse_bridge_method_post();
+  const realtime = executeRequest(methodGet, '/realtime/abc', [
+    { name: 'X-Pulse-Test', value: 'edge' },
+    { name: 'X-Pulse-Multi', value: 'one' },
+    { name: 'x-pulse-multi', value: 'two' }
+  ]);
+  const compute = executeRequest(methodPost, '/compute/42', [{ name: 'X-Pulse-Test', value: 'edge' }]);
+  const missing = executeRequest(methodGet, '/missing');
+  const connectInvoked = executeLifecycle('connect', methodGet, '/realtime/abc');
+  const disconnectInvoked = executeLifecycle('disconnect', methodGet, '/realtime/abc');
+  const error = makeError('PULSEWASM_TEST', 'host bridge error', 599);
+  const errorCode = readStringRef(instance.exports.pulse_error_code_ref(error));
+  const errorMessage = readStringRef(instance.exports.pulse_error_message_ref(error));
+
+  const checks = [
+    { name: 'route_count', expected: 2, actual: instance.exports.pulse_bridge_route_count() },
+    { name: 'execution_entry_count', expected: 8, actual: instance.exports.pulse_bridge_execution_entry_count() },
+    { name: 'handler_binding_count', expected: 7, actual: instance.exports.pulse_bridge_handler_binding_count() },
+    { name: 'request_realtime_status', expected: 200, actual: realtime.status },
+    { name: 'request_realtime_body', expected: 'realtime:abc', actual: realtime.body },
+    { name: 'request_realtime_param', expected: 'abc', actual: observedParams.realtimeId },
+    { name: 'request_realtime_broadcaster', expected: 1, actual: broadcasterCalls.length >= 1 ? 1 : 0 },
+    { name: 'request_header_first', expected: 'edge', actual: observedHeaders.requestFirst },
+    { name: 'request_header_multi_count', expected: 2, actual: observedHeaders.requestMultiCount },
+    { name: 'request_header_multi_second', expected: 'two', actual: observedHeaders.requestMultiSecond },
+    { name: 'response_header_count', expected: 4, actual: realtime.headerCount },
+    { name: 'response_header_grip_channel_count', expected: 2, actual: realtime.gripChannels.length },
+    { name: 'response_header_grip_channel_second', expected: 'realtime:abc', actual: realtime.gripChannels[1] },
+    { name: 'request_compute_status', expected: 201, actual: compute.status },
+    { name: 'request_compute_body', expected: 'compute:42', actual: compute.body },
+    { name: 'response_header_delete', expected: 0, actual: headerValues(compute.headers, 'Temp-Header').length },
+    { name: 'request_compute_param', expected: '42', actual: observedParams.computeId },
+    { name: 'ctx_state_map_bridge', expected: '1', actual: observedState.gatewaySawAuth },
+    { name: 'missing_fallthrough_status', expected: 404, actual: missing.status },
+    { name: 'connect_lifecycle_invoked', expected: 1, actual: connectInvoked },
+    { name: 'disconnect_lifecycle_invoked', expected: 1, actual: disconnectInvoked },
+    { name: 'error_code_ref', expected: 'PULSEWASM_TEST', actual: errorCode },
+    { name: 'error_message_ref', expected: 'host bridge error', actual: errorMessage },
+    { name: 'handler_auth_called', expected: 1, actual: handlerCalls.auth >= 1 ? 1 : 0 },
+    { name: 'handler_gateway_called', expected: 1, actual: handlerCalls.gateway >= 1 ? 1 : 0 },
+    { name: 'handler_realtime_called', expected: 1, actual: handlerCalls.realtimeHandler >= 1 ? 1 : 0 },
+    { name: 'handler_compute_called', expected: 1, actual: handlerCalls.computeHandler >= 1 ? 1 : 0 },
+    { name: 'handler_channel_called', expected: 1, actual: handlerCalls.bundleChannel >= 1 ? 1 : 0 }
+  ].map((check) => ({ ...check, status: check.actual === check.expected ? 'ok' : 'error', message: check.actual === check.expected ? undefined : `Expected ${check.expected}, got ${check.actual}.` }));
+
+  return {
+    imports,
+    exports,
+    checks,
+    handlerCalls,
+    broadcasterCalls,
+    observedParams,
+    observedState,
+    observedHeaders,
+    results: { realtime, compute, missing, connectInvoked, disconnectInvoked, errorCode, errorMessage },
+    memoryExported: Boolean(instance.exports.memory),
+    instanceExports: Object.keys(instance.exports)
+  };
+}
+
+function buildArtifact(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const diagnostics = options.diagnostics || [];
+  const checks = options.bridge?.checks || [];
+  const failedChecks = checks.filter((check) => check.status !== 'ok');
+  return normalizeArtifact({
+    version: WASM_BRIDGE_VERSION,
+    generatedBy: options.generatedBy || PACKAGE_VERSION,
+    status: diagnostics.length || failedChecks.length ? 'error' : 'ok',
+    sourceWasmHostAbiVersion: options.wasmHostAbi?.artifact?.version,
+    sourceAssemblyScriptCoreVersion: options.core?.artifact?.version,
+    policy: {
+      phase: WASM_BRIDGE_PHASE,
+      sourceOfTruth: 'wasm-host-abi.json + request-result-headers.json + generated/as/*.as.ts',
+      reReadsSource: false,
+      reInfersRouteSemantics: false,
+      compiler: 'assemblyscript asc',
+      wasmCompiled: true,
+      wasmInstantiated: Boolean(options.bridge),
+      wasmExecutedThroughHostAbi: Boolean(options.bridge),
+      hostBridgeImplemented: true,
+      platformBindings: false,
+      witBindings: false,
+      wasiHttp: false,
+      stringAbi: 'host writes UTF-8 through pulse_alloc; wasm decodes ptr + byteLen',
+      handlers: 'host imports call exported continuation/result/ctx/header operations',
+      headers: 'ordered repeated request/response headers implemented; result headers exported by iteration',
+      bodyPolicy: 'request body deferred; RESULT_TEXT/JSON/EMPTY implemented; RESULT_STREAM implemented for host-owned pass-through; RESULT_BINARY reserved',
+      broadcaster: 'host import required; missing broadcaster rejected during instantiation'
+    },
+    compiler: {
+      package: 'assemblyscript',
+      version: options.assemblyScriptVersion,
+      executable: options.asc?.display
+    },
+    command: options.command,
+    result: options.result ? { exitCode: options.result.status, signal: options.result.signal, durationMs: options.durationMs, stdout: String(options.result.stdout || ''), stderr: String(options.result.stderr || '') } : undefined,
+    generated: { inputFiles: options.inputFiles || [], outputFiles: options.outputFiles || [] },
+    wasmModule: options.bridge ? { imports: options.bridge.imports, exports: options.bridge.exports, memoryExported: options.bridge.memoryExported, instanceExports: options.bridge.instanceExports } : undefined,
+    bridge: options.bridge ? {
+      checks: options.bridge.checks,
+      failedChecks,
+      handlerCalls: options.bridge.handlerCalls,
+      broadcasterCalls: options.bridge.broadcasterCalls.length,
+      observedParams: options.bridge.observedParams,
+      observedState: options.bridge.observedState,
+      observedHeaders: options.bridge.observedHeaders,
+      results: options.bridge.results
+    } : undefined,
+    missingBroadcaster: options.missingBroadcaster,
+    diagnostics,
+    warnings: options.warnings || [],
+    summary: {
+      compiled: Boolean(options.outputFiles && options.outputFiles.length),
+      instantiated: Boolean(options.bridge),
+      executed: Boolean(options.bridge),
+      hostBridge: Boolean(options.bridge),
+      checks: checks.length,
+      failedChecks: failedChecks.length,
+      handlerCalls: options.bridge ? Object.values(options.bridge.handlerCalls).reduce((sum, value) => sum + Number(value || 0), 0) : 0,
+      broadcasterCalls: options.bridge ? options.bridge.broadcasterCalls.length : 0,
+      headersAdapted: Boolean(options.bridge),
+      requestHeaderChecks: checks.filter((check) => check.name.startsWith('request_header_')).length,
+      responseHeaderChecks: checks.filter((check) => check.name.startsWith('response_header_')).length,
+      repeatedHeadersPreserved: Boolean(options.bridge?.results?.realtime?.gripChannels?.length === 2),
+      missingBroadcasterRejected: Boolean(options.missingBroadcaster?.missingBroadcasterRejected),
+      wasmBytes: options.outputFiles?.find((file) => file.kind === 'wasm-host-bridge-output')?.bytes || 0,
+      watBytes: options.outputFiles?.find((file) => file.kind === 'wat-host-bridge-output')?.bytes || 0,
+      diagnostics: diagnostics.length,
+      warnings: (options.warnings || []).length,
+      platformBindings: false,
+      witBindings: false
+    }
+  }, cwd);
+}
+
+function buildWasmHostBridge(shape, core, wasmHostAbi, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const generatedBy = options.generatedBy || PACKAGE_VERSION;
+  const diagnostics = [];
+  const bridgeRunnerText = buildBridgeRunnerSource();
+  const stagingDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pulsewasm-host-bridge-'));
+  const inputFiles = writeStagedFiles(stagingDir, shape, core, bridgeRunnerText);
+  const compile = compileBridge(stagingDir, cwd, options);
+  diagnostics.push(...(compile.diagnostics || []));
+
+  let outputFiles = [];
+  let bridge;
+  let missingBroadcaster;
+  if (diagnostics.length === 0 && compile.wasmFile && fs.existsSync(compile.wasmFile)) {
+    outputFiles = [fileRecord(compile.wasmFile, cwd, 'wasm-host-bridge-output'), fileRecord(compile.watFile, cwd, 'wat-host-bridge-output')];
+    try {
+      missingBroadcaster = instantiateWithoutBroadcaster(compile.wasmFile);
+      bridge = instantiateAndRunBridge(compile.wasmFile);
+      const failed = bridge.checks.filter((check) => check.status !== 'ok');
+      if (failed.length > 0) diagnostics.push(diagnosticFromParts({ phase: 'wasm-host-bridge', code: 'PULSEWASM_WASM_HOST_BRIDGE_CHECK_FAILED', message: 'Phase 10D Wasm host bridge checks failed.', hint: 'Inspect wasm-host-bridge.json bridge.failedChecks for details.', details: { failed } }));
+      if (!missingBroadcaster.missingBroadcasterRejected) diagnostics.push(diagnosticFromParts({ phase: 'wasm-host-bridge', code: 'PULSEWASM_WASM_HOST_BRIDGE_BROADCASTER_NOT_REQUIRED', message: 'The Phase 10D bridge did not reject a missing broadcaster import.', hint: 'Channel-resolving builds must require the broadcaster import at this boundary.', details: missingBroadcaster }));
+    } catch (error) {
+      diagnostics.push(diagnosticFromParts({ phase: 'wasm-host-bridge', code: 'PULSEWASM_WASM_HOST_BRIDGE_EXECUTION_FAILED', message: 'Phase 10D Wasm host bridge execution failed.', hint: 'Inspect details for the host-side execution error.', details: { message: error && error.message ? error.message : String(error), stack: error && error.stack ? error.stack : undefined } }));
+    }
+  }
+
+  const command = compile.asc ? {
+    executable: compile.asc.display,
+    args: [path.relative(cwd, path.join(stagingDir, BRIDGE_RUNNER_FILE)).replace(/\\/g, '/'), '--outFile', path.join(options.outDir ? path.relative(cwd, path.resolve(cwd, options.outDir)) : 'artifacts', BRIDGE_WASM_REL).replace(/\\/g, '/'), '--textFile', path.join(options.outDir ? path.relative(cwd, path.resolve(cwd, options.outDir)) : 'artifacts', BRIDGE_WAT_REL).replace(/\\/g, '/'), '--runtime', 'stub', '--noAssert']
+  } : undefined;
+
+  const artifact = buildArtifact({ cwd, generatedBy, shape, core, wasmHostAbi, diagnostics, warnings: compile.warnings || [], asc: compile.asc, command, result: compile.result, durationMs: compile.durationMs, inputFiles, outputFiles, bridge, missingBroadcaster, assemblyScriptVersion: assemblyScriptVersion(cwd) });
+  return { artifact, files: [{ file: BRIDGE_RUNNER_FILE, text: bridgeRunnerText }], outputFiles, diagnostics };
+}
+
+module.exports = {
+  WASM_BRIDGE_VERSION,
+  buildWasmHostBridge
+};