diff --git a/compiler/wasm/src/compile.rs b/compiler/wasm/src/compile.rs
index c8b1680bc00..ca6c8efedb1 100644
--- a/compiler/wasm/src/compile.rs
+++ b/compiler/wasm/src/compile.rs
@@ -6,8 +6,7 @@ use nargo::artifacts::{
     program::ProgramArtifact,
 };
 use noirc_driver::{
-    add_dep, compile_contract, compile_main, file_manager_with_stdlib, prepare_crate,
-    prepare_dependency, CompileOptions, CompiledContract, CompiledProgram,
+    add_dep, file_manager_with_stdlib, prepare_crate, prepare_dependency, CompileOptions,
     NOIR_ARTIFACT_VERSION_STRING,
 };
 use noirc_evaluator::errors::SsaReport;
@@ -60,51 +59,64 @@ extern "C" {
     #[derive(Clone, Debug, PartialEq, Eq)]
     pub type JsDependencyGraph;
 
-    #[wasm_bindgen(extends = Object, js_name = "CompileResult", typescript_type = "CompileResult")]
+    #[wasm_bindgen(extends = Object, js_name = "ProgramCompileResult", typescript_type = "ProgramCompileResult")]
     #[derive(Clone, Debug, PartialEq, Eq)]
-    pub type JsCompileResult;
+    pub type JsCompileProgramResult;
 
     #[wasm_bindgen(constructor, js_class = "Object")]
-    fn constructor() -> JsCompileResult;
+    fn constructor() -> JsCompileProgramResult;
+
+    #[wasm_bindgen(extends = Object, js_name = "ContractCompileResult", typescript_type = "ContractCompileResult")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type JsCompileContractResult;
+
+    #[wasm_bindgen(constructor, js_class = "Object")]
+    fn constructor() -> JsCompileContractResult;
 }
 
-impl JsCompileResult {
-    const CONTRACT_PROP: &'static str = "contract";
+impl JsCompileProgramResult {
     const PROGRAM_PROP: &'static str = "program";
     const WARNINGS_PROP: &'static str = "warnings";
 
-    pub fn new(resp: CompileResult) -> JsCompileResult {
-        let obj = JsCompileResult::constructor();
-        match resp {
-            CompileResult::Contract { contract, warnings } => {
-                js_sys::Reflect::set(
-                    &obj,
-                    &JsString::from(JsCompileResult::CONTRACT_PROP),
-                    &<JsValue as JsValueSerdeExt>::from_serde(&contract).unwrap(),
-                )
-                .unwrap();
-                js_sys::Reflect::set(
-                    &obj,
-                    &JsString::from(JsCompileResult::WARNINGS_PROP),
-                    &<JsValue as JsValueSerdeExt>::from_serde(&warnings).unwrap(),
-                )
-                .unwrap();
-            }
-            CompileResult::Program { program, warnings } => {
-                js_sys::Reflect::set(
-                    &obj,
-                    &JsString::from(JsCompileResult::PROGRAM_PROP),
-                    &<JsValue as JsValueSerdeExt>::from_serde(&program).unwrap(),
-                )
-                .unwrap();
-                js_sys::Reflect::set(
-                    &obj,
-                    &JsString::from(JsCompileResult::WARNINGS_PROP),
-                    &<JsValue as JsValueSerdeExt>::from_serde(&warnings).unwrap(),
-                )
-                .unwrap();
-            }
-        };
+    pub fn new(program: ProgramArtifact, warnings: Vec<SsaReport>) -> JsCompileProgramResult {
+        let obj = JsCompileProgramResult::constructor();
+
+        js_sys::Reflect::set(
+            &obj,
+            &JsString::from(JsCompileProgramResult::PROGRAM_PROP),
+            &<JsValue as JsValueSerdeExt>::from_serde(&program).unwrap(),
+        )
+        .unwrap();
+        js_sys::Reflect::set(
+            &obj,
+            &JsString::from(JsCompileProgramResult::WARNINGS_PROP),
+            &<JsValue as JsValueSerdeExt>::from_serde(&warnings).unwrap(),
+        )
+        .unwrap();
+
+        obj
+    }
+}
+
+impl JsCompileContractResult {
+    const CONTRACT_PROP: &'static str = "contract";
+    const WARNINGS_PROP: &'static str = "warnings";
+
+    pub fn new(contract: ContractArtifact, warnings: Vec<SsaReport>) -> JsCompileContractResult {
+        let obj = JsCompileContractResult::constructor();
+
+        js_sys::Reflect::set(
+            &obj,
+            &JsString::from(JsCompileContractResult::CONTRACT_PROP),
+            &<JsValue as JsValueSerdeExt>::from_serde(&contract).unwrap(),
+        )
+        .unwrap();
+        js_sys::Reflect::set(
+            &obj,
+            &JsString::from(JsCompileContractResult::WARNINGS_PROP),
+            &<JsValue as JsValueSerdeExt>::from_serde(&warnings).unwrap(),
+        )
+        .unwrap();
 
         obj
     }
@@ -144,73 +156,98 @@ pub(crate) fn parse_all(fm: &FileManager) -> ParsedFiles {
     fm.as_file_map().all_file_ids().map(|&file_id| (file_id, parse_file(fm, file_id))).collect()
 }
 
-pub enum CompileResult {
-    Contract { contract: ContractArtifact, warnings: Vec<SsaReport> },
-    Program { program: ProgramArtifact, warnings: Vec<SsaReport> },
-}
-
 #[wasm_bindgen]
-pub fn compile(
+pub fn compile_program(
     entry_point: String,
-    contracts: Option<bool>,
     dependency_graph: Option<JsDependencyGraph>,
     file_source_map: PathToFileSourceMap,
-) -> Result<JsCompileResult, JsCompileError> {
+) -> Result<JsCompileProgramResult, JsCompileError> {
     console_error_panic_hook::set_once();
-
-    let dependency_graph: DependencyGraph = if let Some(dependency_graph) = dependency_graph {
-        <JsValue as JsValueSerdeExt>::into_serde(&JsValue::from(dependency_graph))
-            .map_err(|err| err.to_string())?
-    } else {
-        DependencyGraph { root_dependencies: vec![], library_dependencies: HashMap::new() }
-    };
-
-    let fm = file_manager_with_source_map(file_source_map);
-    let parsed_files = parse_all(&fm);
-    let mut context = Context::new(fm, parsed_files);
-
-    let path = Path::new(&entry_point);
-    let crate_id = prepare_crate(&mut context, path);
-
-    process_dependency_graph(&mut context, dependency_graph);
+    let (crate_id, mut context) = prepare_context(entry_point, dependency_graph, file_source_map)?;
 
     let compile_options = CompileOptions::default();
-
     // For now we default to a bounded width of 3, though we can add it as a parameter
     let expression_width = acvm::acir::circuit::ExpressionWidth::Bounded { width: 3 };
 
-    if contracts.unwrap_or_default() {
-        let compiled_contract = compile_contract(&mut context, crate_id, &compile_options)
+    let compiled_program =
+        noirc_driver::compile_main(&mut context, crate_id, &compile_options, None)
             .map_err(|errs| {
                 CompileError::with_file_diagnostics(
-                    "Failed to compile contract",
+                    "Failed to compile program",
                     errs,
                     &context.file_manager,
                 )
             })?
             .0;
 
-        let optimized_contract =
-            nargo::ops::transform_contract(compiled_contract, expression_width);
+    let optimized_program = nargo::ops::transform_program(compiled_program, expression_width);
+    let warnings = optimized_program.warnings.clone();
 
-        let compile_output = generate_contract_artifact(optimized_contract);
-        Ok(JsCompileResult::new(compile_output))
-    } else {
-        let compiled_program = compile_main(&mut context, crate_id, &compile_options, None)
+    Ok(JsCompileProgramResult::new(optimized_program.into(), warnings))
+}
+
+#[wasm_bindgen]
+pub fn compile_contract(
+    entry_point: String,
+    dependency_graph: Option<JsDependencyGraph>,
+    file_source_map: PathToFileSourceMap,
+) -> Result<JsCompileContractResult, JsCompileError> {
+    console_error_panic_hook::set_once();
+    let (crate_id, mut context) = prepare_context(entry_point, dependency_graph, file_source_map)?;
+
+    let compile_options = CompileOptions::default();
+    // For now we default to a bounded width of 3, though we can add it as a parameter
+    let expression_width = acvm::acir::circuit::ExpressionWidth::Bounded { width: 3 };
+
+    let compiled_contract =
+        noirc_driver::compile_contract(&mut context, crate_id, &compile_options)
             .map_err(|errs| {
                 CompileError::with_file_diagnostics(
-                    "Failed to compile program",
+                    "Failed to compile contract",
                     errs,
                     &context.file_manager,
                 )
             })?
             .0;
 
-        let optimized_program = nargo::ops::transform_program(compiled_program, expression_width);
+    let optimized_contract = nargo::ops::transform_contract(compiled_contract, expression_width);
 
-        let compile_output = generate_program_artifact(optimized_program);
-        Ok(JsCompileResult::new(compile_output))
-    }
+    let functions =
+        optimized_contract.functions.into_iter().map(ContractFunctionArtifact::from).collect();
+
+    let contract_artifact = ContractArtifact {
+        noir_version: String::from(NOIR_ARTIFACT_VERSION_STRING),
+        name: optimized_contract.name,
+        functions,
+        events: optimized_contract.events,
+        file_map: optimized_contract.file_map,
+    };
+
+    Ok(JsCompileContractResult::new(contract_artifact, optimized_contract.warnings))
+}
+
+fn prepare_context(
+    entry_point: String,
+    dependency_graph: Option<JsDependencyGraph>,
+    file_source_map: PathToFileSourceMap,
+) -> Result<(CrateId, Context<'static, 'static>), JsCompileError> {
+    let dependency_graph: DependencyGraph = if let Some(dependency_graph) = dependency_graph {
+        <JsValue as JsValueSerdeExt>::into_serde(&JsValue::from(dependency_graph))
+            .map_err(|err| err.to_string())?
+    } else {
+        DependencyGraph { root_dependencies: vec![], library_dependencies: HashMap::new() }
+    };
+
+    let fm = file_manager_with_source_map(file_source_map);
+    let parsed_files = parse_all(&fm);
+    let mut context = Context::new(fm, parsed_files);
+
+    let path = Path::new(&entry_point);
+    let crate_id = prepare_crate(&mut context, path);
+
+    process_dependency_graph(&mut context, dependency_graph);
+
+    Ok((crate_id, context))
 }
 
 // Create a new FileManager with the given source map
@@ -270,25 +307,6 @@ fn add_noir_lib(context: &mut Context, library_name: &CrateName) -> CrateId {
     prepare_dependency(context, &path_to_lib)
 }
 
-pub(crate) fn generate_program_artifact(program: CompiledProgram) -> CompileResult {
-    let warnings = program.warnings.clone();
-    CompileResult::Program { program: program.into(), warnings }
-}
-
-pub(crate) fn generate_contract_artifact(contract: CompiledContract) -> CompileResult {
-    let functions = contract.functions.into_iter().map(ContractFunctionArtifact::from).collect();
-
-    let contract_artifact = ContractArtifact {
-        noir_version: String::from(NOIR_ARTIFACT_VERSION_STRING),
-        name: contract.name,
-        functions,
-        events: contract.events,
-        file_map: contract.file_map,
-    };
-
-    CompileResult::Contract { contract: contract_artifact, warnings: contract.warnings }
-}
-
 #[cfg(test)]
 mod test {
     use noirc_driver::prepare_crate;
diff --git a/compiler/wasm/src/compile_new.rs b/compiler/wasm/src/compile_new.rs
index f8fbed4f470..2a5f7ab6545 100644
--- a/compiler/wasm/src/compile_new.rs
+++ b/compiler/wasm/src/compile_new.rs
@@ -1,10 +1,12 @@
 use crate::compile::{
-    file_manager_with_source_map, generate_contract_artifact, generate_program_artifact, parse_all,
-    JsCompileResult, PathToFileSourceMap,
+    file_manager_with_source_map, parse_all, JsCompileContractResult, JsCompileProgramResult,
+    PathToFileSourceMap,
 };
 use crate::errors::{CompileError, JsCompileError};
+use nargo::artifacts::contract::{ContractArtifact, ContractFunctionArtifact};
 use noirc_driver::{
     add_dep, compile_contract, compile_main, prepare_crate, prepare_dependency, CompileOptions,
+    NOIR_ARTIFACT_VERSION_STRING,
 };
 use noirc_frontend::{
     graph::{CrateId, CrateName},
@@ -92,7 +94,7 @@ impl CompilerContext {
     pub fn compile_program(
         mut self,
         program_width: usize,
-    ) -> Result<JsCompileResult, JsCompileError> {
+    ) -> Result<JsCompileProgramResult, JsCompileError> {
         let compile_options = CompileOptions::default();
         let np_language = acvm::acir::circuit::ExpressionWidth::Bounded { width: program_width };
 
@@ -110,15 +112,15 @@ impl CompilerContext {
                 .0;
 
         let optimized_program = nargo::ops::transform_program(compiled_program, np_language);
+        let warnings = optimized_program.warnings.clone();
 
-        let compile_output = generate_program_artifact(optimized_program);
-        Ok(JsCompileResult::new(compile_output))
+        Ok(JsCompileProgramResult::new(optimized_program.into(), warnings))
     }
 
     pub fn compile_contract(
         mut self,
         program_width: usize,
-    ) -> Result<JsCompileResult, JsCompileError> {
+    ) -> Result<JsCompileContractResult, JsCompileError> {
         let compile_options = CompileOptions::default();
         let np_language = acvm::acir::circuit::ExpressionWidth::Bounded { width: program_width };
         let root_crate_id = *self.context.root_crate_id();
@@ -136,24 +138,64 @@ impl CompilerContext {
 
         let optimized_contract = nargo::ops::transform_contract(compiled_contract, np_language);
 
-        let compile_output = generate_contract_artifact(optimized_contract);
-        Ok(JsCompileResult::new(compile_output))
+        let functions =
+            optimized_contract.functions.into_iter().map(ContractFunctionArtifact::from).collect();
+
+        let contract_artifact = ContractArtifact {
+            noir_version: String::from(NOIR_ARTIFACT_VERSION_STRING),
+            name: optimized_contract.name,
+            functions,
+            events: optimized_contract.events,
+            file_map: optimized_contract.file_map,
+        };
+
+        Ok(JsCompileContractResult::new(contract_artifact, optimized_contract.warnings))
     }
 }
 
 /// This is a method that exposes the same API as `compile`
 /// But uses the Context based APi internally
 #[wasm_bindgen]
-pub fn compile_(
+pub fn compile_program_(
     entry_point: String,
-    contracts: Option<bool>,
     dependency_graph: Option<crate::compile::JsDependencyGraph>,
     file_source_map: PathToFileSourceMap,
-) -> Result<JsCompileResult, JsCompileError> {
-    use std::collections::HashMap;
+) -> Result<JsCompileProgramResult, JsCompileError> {
+    console_error_panic_hook::set_once();
+
+    let compiler_context =
+        prepare_compiler_context(entry_point, dependency_graph, file_source_map)?;
+    let program_width = 3;
 
+    compiler_context.compile_program(program_width)
+}
+
+/// This is a method that exposes the same API as `compile`
+/// But uses the Context based APi internally
+#[wasm_bindgen]
+pub fn compile_contract_(
+    entry_point: String,
+    dependency_graph: Option<crate::compile::JsDependencyGraph>,
+    file_source_map: PathToFileSourceMap,
+) -> Result<JsCompileContractResult, JsCompileError> {
     console_error_panic_hook::set_once();
 
+    let compiler_context =
+        prepare_compiler_context(entry_point, dependency_graph, file_source_map)?;
+    let program_width = 3;
+
+    compiler_context.compile_contract(program_width)
+}
+
+/// This is a method that exposes the same API as `prepare_context`
+/// But uses the Context based API internally
+fn prepare_compiler_context(
+    entry_point: String,
+    dependency_graph: Option<crate::compile::JsDependencyGraph>,
+    file_source_map: PathToFileSourceMap,
+) -> Result<CompilerContext, JsCompileError> {
+    use std::collections::HashMap;
+
     let dependency_graph: crate::compile::DependencyGraph =
         if let Some(dependency_graph) = dependency_graph {
             <wasm_bindgen::JsValue as gloo_utils::format::JsValueSerdeExt>::into_serde(
@@ -218,14 +260,7 @@ pub fn compile_(
         }
     }
 
-    let is_contract = contracts.unwrap_or(false);
-    let program_width = 3;
-
-    if is_contract {
-        compiler_context.compile_contract(program_width)
-    } else {
-        compiler_context.compile_program(program_width)
-    }
+    Ok(compiler_context)
 }
 
 #[cfg(test)]
diff --git a/compiler/wasm/src/index.cts b/compiler/wasm/src/index.cts
index 7c707e662d8..234bfa7280c 100644
--- a/compiler/wasm/src/index.cts
+++ b/compiler/wasm/src/index.cts
@@ -2,7 +2,7 @@ import { FileManager } from './noir/file-manager/file-manager';
 import { createNodejsFileManager } from './noir/file-manager/nodejs-file-manager';
 import { NoirWasmCompiler } from './noir/noir-wasm-compiler';
 import { LogData, LogFn } from './utils';
-import { CompilationResult } from './types/noir_artifact';
+import { ContractCompilationArtifacts, ProgramCompilationArtifacts } from './types/noir_artifact';
 import { inflateDebugSymbols } from './noir/debug';
 
 /**
@@ -17,36 +17,86 @@ import { inflateDebugSymbols } from './noir/debug';
  * ```typescript
  * // Node.js
  *
- * import { compile, createFileManager } from '@noir-lang/noir_wasm';
+ * import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
  *
  * const fm = createFileManager(myProjectPath);
- * const myCompiledCode = await compile(fm);
+ * const myCompiledCode = await compile_program(fm);
  * ```
  *
  * ```typescript
  * // Browser
  *
- * import { compile, createFileManager } from '@noir-lang/noir_wasm';
+ * import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
  *
  * const fm = createFileManager('/');
  * for (const path of files) {
  *   await fm.writeFile(path, await getFileAsStream(path));
  * }
- * const myCompiledCode = await compile(fm);
+ * const myCompiledCode = await compile_program(fm);
  * ```
  */
-async function compile(
+async function compile_program(
   fileManager: FileManager,
   projectPath?: string,
   logFn?: LogFn,
   debugLogFn?: LogFn,
-): Promise<CompilationResult> {
+): Promise<ProgramCompilationArtifacts> {
+  const compiler = await setup_compiler(fileManager, projectPath, logFn, debugLogFn);
+  return await compiler.compile_program();
+}
+
+/**
+ * Compiles a Noir project
+ *
+ * @param fileManager - The file manager to use
+ * @param projectPath - The path to the project inside the file manager. Defaults to the root of the file manager
+ * @param logFn - A logging function. If not provided, console.log will be used
+ * @param debugLogFn - A debug logging function. If not provided, logFn will be used
+ *
+ * @example
+ * ```typescript
+ * // Node.js
+ *
+ * import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+ *
+ * const fm = createFileManager(myProjectPath);
+ * const myCompiledCode = await compile_contract(fm);
+ * ```
+ *
+ * ```typescript
+ * // Browser
+ *
+ * import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+ *
+ * const fm = createFileManager('/');
+ * for (const path of files) {
+ *   await fm.writeFile(path, await getFileAsStream(path));
+ * }
+ * const myCompiledCode = await compile_contract(fm);
+ * ```
+ */
+async function compile_contract(
+  fileManager: FileManager,
+  projectPath?: string,
+  logFn?: LogFn,
+  debugLogFn?: LogFn,
+): Promise<ContractCompilationArtifacts> {
+  const compiler = await setup_compiler(fileManager, projectPath, logFn, debugLogFn);
+  return await compiler.compile_contract();
+}
+
+async function setup_compiler(
+  fileManager: FileManager,
+  projectPath?: string,
+  logFn?: LogFn,
+  debugLogFn?: LogFn,
+): Promise<NoirWasmCompiler> {
   if (logFn && !debugLogFn) {
     debugLogFn = logFn;
   }
 
   const cjs = await require('../build/cjs');
-  const compiler = await NoirWasmCompiler.new(
+  return await NoirWasmCompiler.new(
     fileManager,
     projectPath ?? fileManager.getDataDir(),
     cjs,
@@ -72,9 +122,16 @@ async function compile(
         },
     },
   );
-  return await compiler.compile();
 }
 
 const createFileManager = createNodejsFileManager;
 
-export { compile, createFileManager, inflateDebugSymbols, CompilationResult };
+export {
+  compile_program as compile,
+  compile_program,
+  compile_contract,
+  createFileManager,
+  inflateDebugSymbols,
+  ProgramCompilationArtifacts,
+  ContractCompilationArtifacts,
+};
diff --git a/compiler/wasm/src/index.mts b/compiler/wasm/src/index.mts
index d4ed0beccfc..326a7337117 100644
--- a/compiler/wasm/src/index.mts
+++ b/compiler/wasm/src/index.mts
@@ -2,7 +2,7 @@ import { FileManager } from './noir/file-manager/file-manager';
 import { createNodejsFileManager } from './noir/file-manager/nodejs-file-manager';
 import { NoirWasmCompiler } from './noir/noir-wasm-compiler';
 import { LogData, LogFn } from './utils';
-import { CompilationResult } from './types/noir_artifact';
+import { ContractCompilationArtifacts, ProgramCompilationArtifacts } from './types/noir_artifact';
 import { inflateDebugSymbols } from './noir/debug';
 
 /**
@@ -17,30 +17,80 @@ import { inflateDebugSymbols } from './noir/debug';
  * ```typescript
  * // Node.js
  *
- * import { compile, createFileManager } from '@noir-lang/noir_wasm';
+ * import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
  *
  * const fm = createFileManager(myProjectPath);
- * const myCompiledCode = await compile(fm);
+ * const myCompiledCode = await compile_program(fm);
  * ```
  *
  * ```typescript
  * // Browser
  *
- * import { compile, createFileManager } from '@noir-lang/noir_wasm';
+ * import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
  *
  * const fm = createFileManager('/');
  * for (const path of files) {
  *   await fm.writeFile(path, await getFileAsStream(path));
  * }
- * const myCompiledCode = await compile(fm);
+ * const myCompiledCode = await compile_program(fm);
  * ```
  */
-async function compile(
+async function compile_program(
   fileManager: FileManager,
   projectPath?: string,
   logFn?: LogFn,
   debugLogFn?: LogFn,
-): Promise<CompilationResult> {
+): Promise<ProgramCompilationArtifacts> {
+  const compiler = await setup_compiler(fileManager, projectPath, logFn, debugLogFn);
+  return await compiler.compile_program();
+}
+
+/**
+ * Compiles a Noir project
+ *
+ * @param fileManager - The file manager to use
+ * @param projectPath - The path to the project inside the file manager. Defaults to the root of the file manager
+ * @param logFn - A logging function. If not provided, console.log will be used
+ * @param debugLogFn - A debug logging function. If not provided, logFn will be used
+ *
+ * @example
+ * ```typescript
+ * // Node.js
+ *
+ * import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+ *
+ * const fm = createFileManager(myProjectPath);
+ * const myCompiledCode = await compile_contract(fm);
+ * ```
+ *
+ * ```typescript
+ * // Browser
+ *
+ * import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+ *
+ * const fm = createFileManager('/');
+ * for (const path of files) {
+ *   await fm.writeFile(path, await getFileAsStream(path));
+ * }
+ * const myCompiledCode = await compile_contract(fm);
+ * ```
+ */
+async function compile_contract(
+  fileManager: FileManager,
+  projectPath?: string,
+  logFn?: LogFn,
+  debugLogFn?: LogFn,
+): Promise<ContractCompilationArtifacts> {
+  const compiler = await setup_compiler(fileManager, projectPath, logFn, debugLogFn);
+  return await compiler.compile_contract();
+}
+
+async function setup_compiler(
+  fileManager: FileManager,
+  projectPath?: string,
+  logFn?: LogFn,
+  debugLogFn?: LogFn,
+): Promise<NoirWasmCompiler> {
   if (logFn && !debugLogFn) {
     debugLogFn = logFn;
   }
@@ -48,7 +98,7 @@ async function compile(
   const esm = await import(/* webpackMode: "eager" */ '../build/esm');
   await esm.default();
 
-  const compiler = await NoirWasmCompiler.new(
+  return await NoirWasmCompiler.new(
     fileManager,
     projectPath ?? fileManager.getDataDir(),
     esm,
@@ -74,9 +124,16 @@ async function compile(
         },
     },
   );
-  return await compiler.compile();
 }
 
 const createFileManager = createNodejsFileManager;
 
-export { compile, createFileManager, inflateDebugSymbols, CompilationResult };
+export {
+  compile_program as compile,
+  compile_program,
+  compile_contract,
+  createFileManager,
+  inflateDebugSymbols,
+  ProgramCompilationArtifacts,
+  ContractCompilationArtifacts,
+};
diff --git a/compiler/wasm/src/lib.rs b/compiler/wasm/src/lib.rs
index 174d9b9ce9c..6753faf2009 100644
--- a/compiler/wasm/src/lib.rs
+++ b/compiler/wasm/src/lib.rs
@@ -18,10 +18,10 @@ mod compile;
 mod compile_new;
 mod errors;
 
-pub use compile::compile;
+pub use compile::{compile_contract, compile_program};
 
 // Expose the new Context-Centric API
-pub use compile_new::{compile_, CompilerContext, CrateIDWrapper};
+pub use compile_new::{compile_contract_, compile_program_, CompilerContext, CrateIDWrapper};
 use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
 
 #[derive(Serialize, Deserialize)]
diff --git a/compiler/wasm/src/noir/noir-wasm-compiler.ts b/compiler/wasm/src/noir/noir-wasm-compiler.ts
index 2a0af5d8fee..1ec3af1fd65 100644
--- a/compiler/wasm/src/noir/noir-wasm-compiler.ts
+++ b/compiler/wasm/src/noir/noir-wasm-compiler.ts
@@ -6,7 +6,7 @@ import { LocalDependencyResolver } from './dependencies/local-dependency-resolve
 import { FileManager } from './file-manager/file-manager';
 import { Package } from './package';
 import { LogFn } from '../utils';
-import { CompilationResult } from '../types/noir_artifact';
+import { ContractCompilationArtifacts, ProgramCompilationArtifacts } from '../types/noir_artifact';
 
 /** Compilation options */
 export type NoirWasmCompileOptions = {
@@ -84,21 +84,64 @@ export class NoirWasmCompiler {
   /**
    * Compile EntryPoint
    */
+  public async compile_program(): Promise<ProgramCompilationArtifacts> {
+    console.log(`Compiling at ${this.#package.getEntryPointPath()}`);
+
+    if (this.#package.getType() !== 'bin') {
+      throw new Error(`Expected to find package type "bin" but found ${this.#package.getType()}`);
+    }
+    await this.#dependencyManager.resolveDependencies();
+    this.#debugLog(`Dependencies: ${this.#dependencyManager.getPackageNames().join(', ')}`);
+
+    try {
+      const entrypoint = this.#package.getEntryPointPath();
+      const deps = {
+        /* eslint-disable camelcase */
+        root_dependencies: this.#dependencyManager.getEntrypointDependencies(),
+        library_dependencies: this.#dependencyManager.getLibraryDependencies(),
+        /* eslint-enable camelcase */
+      };
+      const packageSources = await this.#package.getSources(this.#fm);
+      const librarySources = (
+        await Promise.all(
+          this.#dependencyManager
+            .getLibraries()
+            .map(async ([alias, library]) => await library.package.getSources(this.#fm, alias)),
+        )
+      ).flat();
+      [...packageSources, ...librarySources].forEach((sourceFile) => {
+        this.#debugLog(`Adding source ${sourceFile.path}`);
+        this.#sourceMap.add_source_code(sourceFile.path, sourceFile.source);
+      });
+      const result = this.#wasmCompiler.compile_program(entrypoint, deps, this.#sourceMap);
+
+      return result;
+    } catch (err) {
+      if (err instanceof Error && err.name === 'CompileError') {
+        const logs = await this.#processCompileError(err);
+        for (const log of logs) {
+          this.#log(log);
+        }
+        throw new Error(logs.join('\n'));
+      }
+
+      throw err;
+    }
+  }
+
   /**
    * Compile EntryPoint
    */
-  public async compile(): Promise<CompilationResult> {
+  public async compile_contract(): Promise<ContractCompilationArtifacts> {
     console.log(`Compiling at ${this.#package.getEntryPointPath()}`);
 
-    if (!(this.#package.getType() === 'contract' || this.#package.getType() === 'bin')) {
-      throw new Error(`Only supports compiling "contract" and "bin" package types (${this.#package.getType()})`);
+    if (this.#package.getType() !== 'contract') {
+      throw new Error(`Expected to find package type "contract" but found ${this.#package.getType()}`);
     }
     await this.#dependencyManager.resolveDependencies();
     this.#debugLog(`Dependencies: ${this.#dependencyManager.getPackageNames().join(', ')}`);
 
     try {
-      const isContract: boolean = this.#package.getType() === 'contract';
-
       const entrypoint = this.#package.getEntryPointPath();
       const deps = {
         /* eslint-disable camelcase */
@@ -118,11 +161,7 @@ export class NoirWasmCompiler {
         this.#debugLog(`Adding source ${sourceFile.path}`);
         this.#sourceMap.add_source_code(sourceFile.path, sourceFile.source);
       });
-      const result = this.#wasmCompiler.compile(entrypoint, isContract, deps, this.#sourceMap);
-
-      if ((isContract && !('contract' in result)) || (!isContract && !('program' in result))) {
-        throw new Error('Invalid compilation result');
-      }
+      const result = this.#wasmCompiler.compile_contract(entrypoint, deps, this.#sourceMap);
 
       return result;
     } catch (err) {
diff --git a/compiler/wasm/src/types/noir_artifact.ts b/compiler/wasm/src/types/noir_artifact.ts
index e636212a487..832a6ed9bf9 100644
--- a/compiler/wasm/src/types/noir_artifact.ts
+++ b/compiler/wasm/src/types/noir_artifact.ts
@@ -180,22 +180,3 @@ export interface ProgramCompilationArtifacts {
   /** Compilation warnings. */
   warnings: Warning[];
 }
-
-/**
- * output of Noir Wasm compilation, can be for a contract or lib/binary
- */
-export type CompilationResult = ContractCompilationArtifacts | ProgramCompilationArtifacts;
-
-/**
- * Check if it has Contract unique property
- */
-export function isContractCompilationArtifacts(artifact: CompilationResult): artifact is ContractCompilationArtifacts {
-  return (artifact as ContractCompilationArtifacts).contract !== undefined;
-}
-
-/**
- * Check if it has Contract unique property
- */
-export function isProgramCompilationArtifacts(artifact: CompilationResult): artifact is ProgramCompilationArtifacts {
-  return (artifact as ProgramCompilationArtifacts).program !== undefined;
-}
diff --git a/compiler/wasm/test/compiler/browser/compile.test.ts b/compiler/wasm/test/compiler/browser/compile.test.ts
index b7e6c27427f..7d4b3da55aa 100644
--- a/compiler/wasm/test/compiler/browser/compile.test.ts
+++ b/compiler/wasm/test/compiler/browser/compile.test.ts
@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/ban-ts-comment */
 import { getPaths } from '../../shared';
 import { expect } from '@esm-bundle/chai';
-import { compile, createFileManager } from '@noir-lang/noir_wasm';
+import { compile_program, compile_contract, createFileManager } from '@noir-lang/noir_wasm';
 import { ContractArtifact, ProgramArtifact } from '../../../src/types/noir_artifact';
 import { shouldCompileContractIdentically, shouldCompileProgramIdentically } from '../shared/compile.test';
 
@@ -33,7 +33,7 @@ describe('noir-compiler/browser', () => {
         await fm.writeFile(path, (await getFile(path)).body as ReadableStream<Uint8Array>);
       }
       const nargoArtifact = (await getPrecompiledSource(simpleScriptExpectedArtifact)) as ProgramArtifact;
-      const noirWasmArtifact = await compile(fm, '/fixtures/simple');
+      const noirWasmArtifact = await compile_program(fm, '/fixtures/simple');
 
       return { nargoArtifact, noirWasmArtifact };
     },
@@ -51,7 +51,7 @@ describe('noir-compiler/browser', () => {
         await fm.writeFile(path, (await getFile(path)).body as ReadableStream<Uint8Array>);
       }
       const nargoArtifact = (await getPrecompiledSource(depsScriptExpectedArtifact)) as ProgramArtifact;
-      const noirWasmArtifact = await compile(fm, '/fixtures/with-deps');
+      const noirWasmArtifact = await compile_program(fm, '/fixtures/with-deps');
 
       return { nargoArtifact, noirWasmArtifact };
     },
@@ -69,7 +69,7 @@ describe('noir-compiler/browser', () => {
         await fm.writeFile(path, (await getFile(path)).body as ReadableStream<Uint8Array>);
       }
       const nargoArtifact = (await getPrecompiledSource(contractExpectedArtifact)) as ContractArtifact;
-      const noirWasmArtifact = await compile(fm, '/fixtures/noir-contract');
+      const noirWasmArtifact = await compile_contract(fm, '/fixtures/noir-contract');
 
       return { nargoArtifact, noirWasmArtifact };
     },
diff --git a/compiler/wasm/test/compiler/node/compile.test.ts b/compiler/wasm/test/compiler/node/compile.test.ts
index 9af98195825..811dc95ce16 100644
--- a/compiler/wasm/test/compiler/node/compile.test.ts
+++ b/compiler/wasm/test/compiler/node/compile.test.ts
@@ -2,7 +2,7 @@ import { join, resolve } from 'path';
 import { getPaths } from '../../shared';
 
 import { expect } from 'chai';
-import { compile, createFileManager } from '@noir-lang/noir_wasm';
+import { compile_program, compile_contract, createFileManager } from '@noir-lang/noir_wasm';
 import { readFile } from 'fs/promises';
 import { ContractArtifact, ProgramArtifact } from '../../../src/types/noir_artifact';
 import { shouldCompileContractIdentically, shouldCompileProgramIdentically } from '../shared/compile.test';
@@ -15,7 +15,7 @@ describe('noir-compiler/node', () => {
 
     const fm = createFileManager(simpleScriptProjectPath);
     const nargoArtifact = JSON.parse((await readFile(simpleScriptExpectedArtifact)).toString()) as ProgramArtifact;
-    const noirWasmArtifact = await compile(fm);
+    const noirWasmArtifact = await compile_program(fm);
     return { nargoArtifact, noirWasmArtifact };
   }, expect);
 
@@ -24,7 +24,7 @@ describe('noir-compiler/node', () => {
 
     const fm = createFileManager(depsScriptProjectPath);
     const nargoArtifact = JSON.parse((await readFile(depsScriptExpectedArtifact)).toString()) as ProgramArtifact;
-    const noirWasmArtifact = await compile(fm);
+    const noirWasmArtifact = await compile_program(fm);
     return { nargoArtifact, noirWasmArtifact };
   }, expect);
 
@@ -33,7 +33,7 @@ describe('noir-compiler/node', () => {
 
     const fm = createFileManager(contractProjectPath);
     const nargoArtifact = JSON.parse((await readFile(contractExpectedArtifact)).toString()) as ContractArtifact;
-    const noirWasmArtifact = await compile(fm);
+    const noirWasmArtifact = await compile_contract(fm);
     return { nargoArtifact, noirWasmArtifact };
   }, expect);
 });
diff --git a/compiler/wasm/test/compiler/shared/compile.test.ts b/compiler/wasm/test/compiler/shared/compile.test.ts
index 88e8e8c8e5a..52cef14968b 100644
--- a/compiler/wasm/test/compiler/shared/compile.test.ts
+++ b/compiler/wasm/test/compiler/shared/compile.test.ts
@@ -1,4 +1,4 @@
-import { CompilationResult, inflateDebugSymbols } from '@noir-lang/noir_wasm';
+import { inflateDebugSymbols } from '@noir-lang/noir_wasm';
 import { type expect as Expect } from 'chai';
 import {
   ContractArtifact,
@@ -11,7 +11,7 @@ import {
 } from '../../../src/types/noir_artifact';
 
 export function shouldCompileProgramIdentically(
-  compileFn: () => Promise<{ nargoArtifact: ProgramArtifact; noirWasmArtifact: CompilationResult }>,
+  compileFn: () => Promise<{ nargoArtifact: ProgramArtifact; noirWasmArtifact: ProgramCompilationArtifacts }>,
   expect: typeof Expect,
   timeout = 5000,
 ) {
@@ -24,7 +24,7 @@ export function shouldCompileProgramIdentically(
     normalizeVersion(nargoArtifact);
 
     // Prepare noir-wasm artifact
-    const noirWasmProgram = (noirWasmArtifact as unknown as ProgramCompilationArtifacts).program;
+    const noirWasmProgram = noirWasmArtifact.program;
     expect(noirWasmProgram).not.to.be.undefined;
     const [_noirWasmDebugInfos, norWasmFileMap] = deleteProgramDebugMetadata(noirWasmProgram);
     normalizeVersion(noirWasmProgram);
@@ -47,7 +47,7 @@ export function shouldCompileProgramIdentically(
 }
 
 export function shouldCompileContractIdentically(
-  compileFn: () => Promise<{ nargoArtifact: ContractArtifact; noirWasmArtifact: CompilationResult }>,
+  compileFn: () => Promise<{ nargoArtifact: ContractArtifact; noirWasmArtifact: ContractCompilationArtifacts }>,
   expect: typeof Expect,
   timeout = 5000,
 ) {
@@ -60,7 +60,7 @@ export function shouldCompileContractIdentically(
     normalizeVersion(nargoArtifact);
 
     // Prepare noir-wasm artifact
-    const noirWasmContract = (noirWasmArtifact as unknown as ContractCompilationArtifacts).contract;
+    const noirWasmContract = noirWasmArtifact.contract;
     expect(noirWasmContract).not.to.be.undefined;
     const [noirWasmDebugInfos, norWasmFileMap] = deleteContractDebugMetadata(noirWasmContract);
     normalizeVersion(noirWasmContract);
diff --git a/compiler/wasm/test/wasm/browser/index.test.ts b/compiler/wasm/test/wasm/browser/index.test.ts
index 3122fa57945..b59b4ae417a 100644
--- a/compiler/wasm/test/wasm/browser/index.test.ts
+++ b/compiler/wasm/test/wasm/browser/index.test.ts
@@ -2,7 +2,7 @@
 import { getPaths } from '../../shared';
 import { expect } from '@esm-bundle/chai';
 
-import init, { compile, PathToFileSourceMap, compile_, CompilerContext } from '../../../build/esm';
+import init, { compile_program, PathToFileSourceMap, compile_program_, CompilerContext } from '../../../build/esm';
 
 // @ts-ignore
 await init();
@@ -35,7 +35,7 @@ describe('noir wasm compilation', () => {
     it('matching nargos compilation', async () => {
       const sourceMap = new PathToFileSourceMap();
       sourceMap.add_source_code('script/main.nr', await getFileAsString(simpleScriptSourcePath));
-      const wasmCircuit = compile('script/main.nr', undefined, undefined, sourceMap);
+      const wasmCircuit = compile_program('script/main.nr', undefined, sourceMap);
       const cliCircuit = await getPrecompiledSource(simpleScriptExpectedArtifact);
 
       if (!('program' in wasmCircuit)) {
@@ -58,9 +58,8 @@ describe('noir wasm compilation', () => {
     });
 
     it('matching nargos compilation', async () => {
-      const wasmCircuit = compile(
+      const wasmCircuit = compile_program(
         'script/main.nr',
-        false,
         {
           root_dependencies: ['lib_a'],
           library_dependencies: {
@@ -132,9 +131,8 @@ describe('noir wasm compilation', () => {
     }).timeout(60 * 20e3);
 
     it('matching nargos compilation - context-implementation-compile-api', async () => {
-      const wasmCircuit = await compile_(
+      const wasmCircuit = await compile_program_(
         'script/main.nr',
-        false,
         {
           root_dependencies: ['lib_a'],
           library_dependencies: {
diff --git a/compiler/wasm/test/wasm/node/index.test.ts b/compiler/wasm/test/wasm/node/index.test.ts
index c73ce7477e5..23c87cc059a 100644
--- a/compiler/wasm/test/wasm/node/index.test.ts
+++ b/compiler/wasm/test/wasm/node/index.test.ts
@@ -3,7 +3,7 @@ import { readFileSync } from 'fs';
 import { join, resolve } from 'path';
 import { expect } from 'chai';
 
-import { compile, PathToFileSourceMap, compile_, CompilerContext } from '../../../build/cjs';
+import { compile_program, PathToFileSourceMap, compile_program_, CompilerContext } from '../../../build/cjs';
 
 const basePath = resolve(join(__dirname, '../../'));
 const {
@@ -26,7 +26,7 @@ describe('noir wasm compilation', () => {
     it('matching nargos compilation', async () => {
       const sourceMap = new PathToFileSourceMap();
       sourceMap.add_source_code(simpleScriptSourcePath, readFileSync(simpleScriptSourcePath, 'utf-8'));
-      const wasmCircuit = compile(simpleScriptSourcePath, undefined, undefined, sourceMap);
+      const wasmCircuit = compile_program(simpleScriptSourcePath, undefined, sourceMap);
       const cliCircuit = await getPrecompiledSource(simpleScriptExpectedArtifact);
 
       if (!('program' in wasmCircuit)) {
@@ -49,9 +49,8 @@ describe('noir wasm compilation', () => {
     });
 
     it('matching nargos compilation', async () => {
-      const wasmCircuit = compile(
+      const wasmCircuit = compile_program(
         'script/main.nr',
-        false,
         {
           root_dependencies: ['lib_a'],
           library_dependencies: {
@@ -123,9 +122,8 @@ describe('noir wasm compilation', () => {
     }).timeout(60 * 20e3);
 
     it('matching nargos compilation - context-implementation-compile-api', async () => {
-      const wasmCircuit = await compile_(
+      const wasmCircuit = await compile_program_(
         'script/main.nr',
-        false,
         {
           root_dependencies: ['lib_a'],
           library_dependencies: {